text
stringlengths 1
22.8M
|
|---|
```go
//
// path_to_url
//
// Unless required by applicable law or agreed to in writing, software
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package remote
import (
"context"
"crypto/md5"
"encoding/hex"
"fmt"
"sync"
"time"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/common/model"
"gopkg.in/yaml.v2"
"github.com/prometheus/prometheus/config"
"github.com/prometheus/prometheus/model/labels"
"github.com/prometheus/prometheus/scrape"
"github.com/prometheus/prometheus/storage"
"github.com/prometheus/prometheus/util/logging"
)
// String constants for instrumentation.
const (
namespace = "prometheus"
subsystem = "remote_storage"
remoteName = "remote_name"
endpoint = "url"
)
type ReadyScrapeManager interface {
Get() (*scrape.Manager, error)
}
// startTimeCallback is a callback func that return the oldest timestamp stored in a storage.
type startTimeCallback func() (int64, error)
// Storage represents all the remote read and write endpoints. It implements
// storage.Storage.
type Storage struct {
logger *logging.Deduper
mtx sync.Mutex
rws *WriteStorage
// For reads.
queryables []storage.SampleAndChunkQueryable
localStartTimeCallback startTimeCallback
}
// NewStorage returns a remote.Storage.
func NewStorage(l log.Logger, reg prometheus.Registerer, stCallback startTimeCallback, walDir string, flushDeadline time.Duration, sm ReadyScrapeManager, metadataInWAL bool) *Storage {
if l == nil {
l = log.NewNopLogger()
}
logger := logging.Dedupe(l, 1*time.Minute)
s := &Storage{
logger: logger,
localStartTimeCallback: stCallback,
}
s.rws = NewWriteStorage(s.logger, reg, walDir, flushDeadline, sm, metadataInWAL)
return s
}
func (s *Storage) Notify() {
s.rws.Notify()
}
// ApplyConfig updates the state as the new config requires.
func (s *Storage) ApplyConfig(conf *config.Config) error {
s.mtx.Lock()
defer s.mtx.Unlock()
if err := s.rws.ApplyConfig(conf); err != nil {
return err
}
// Update read clients
readHashes := make(map[string]struct{})
queryables := make([]storage.SampleAndChunkQueryable, 0, len(conf.RemoteReadConfigs))
for _, rrConf := range conf.RemoteReadConfigs {
hash, err := toHash(rrConf)
if err != nil {
return err
}
// Don't allow duplicate remote read configs.
if _, ok := readHashes[hash]; ok {
return fmt.Errorf("duplicate remote read configs are not allowed, found duplicate for URL: %s", rrConf.URL)
}
readHashes[hash] = struct{}{}
// Set the queue name to the config hash if the user has not set
// a name in their remote write config so we can still differentiate
// between queues that have the same remote write endpoint.
name := hash[:6]
if rrConf.Name != "" {
name = rrConf.Name
}
c, err := NewReadClient(name, &ClientConfig{
URL: rrConf.URL,
Timeout: rrConf.RemoteTimeout,
HTTPClientConfig: rrConf.HTTPClientConfig,
Headers: rrConf.Headers,
})
if err != nil {
return err
}
externalLabels := conf.GlobalConfig.ExternalLabels
if !rrConf.FilterExternalLabels {
externalLabels = labels.EmptyLabels()
}
queryables = append(queryables, NewSampleAndChunkQueryableClient(
c,
externalLabels,
labelsToEqualityMatchers(rrConf.RequiredMatchers),
rrConf.ReadRecent,
s.localStartTimeCallback,
))
}
s.queryables = queryables
return nil
}
// StartTime implements the Storage interface.
func (s *Storage) StartTime() (int64, error) {
return int64(model.Latest), nil
}
// Querier returns a storage.MergeQuerier combining the remote client queriers
// of each configured remote read endpoint.
// Returned querier will never return error as all queryables are assumed best effort.
// Additionally all returned queriers ensure that its Select's SeriesSets have ready data after first `Next` invoke.
// This is because Prometheus (fanout and secondary queries) can't handle the stream failing half way through by design.
func (s *Storage) Querier(mint, maxt int64) (storage.Querier, error) {
s.mtx.Lock()
queryables := s.queryables
s.mtx.Unlock()
queriers := make([]storage.Querier, 0, len(queryables))
for _, queryable := range queryables {
q, err := queryable.Querier(mint, maxt)
if err != nil {
return nil, err
}
queriers = append(queriers, q)
}
return storage.NewMergeQuerier(nil, queriers, storage.ChainedSeriesMerge), nil
}
// ChunkQuerier returns a storage.MergeQuerier combining the remote client queriers
// of each configured remote read endpoint.
func (s *Storage) ChunkQuerier(mint, maxt int64) (storage.ChunkQuerier, error) {
s.mtx.Lock()
queryables := s.queryables
s.mtx.Unlock()
queriers := make([]storage.ChunkQuerier, 0, len(queryables))
for _, queryable := range queryables {
q, err := queryable.ChunkQuerier(mint, maxt)
if err != nil {
return nil, err
}
queriers = append(queriers, q)
}
return storage.NewMergeChunkQuerier(nil, queriers, storage.NewCompactingChunkSeriesMerger(storage.ChainedSeriesMerge)), nil
}
// Appender implements storage.Storage.
func (s *Storage) Appender(ctx context.Context) storage.Appender {
return s.rws.Appender(ctx)
}
// LowestSentTimestamp returns the lowest sent timestamp across all queues.
func (s *Storage) LowestSentTimestamp() int64 {
return s.rws.LowestSentTimestamp()
}
// Close the background processing of the storage queues.
func (s *Storage) Close() error {
s.logger.Stop()
s.mtx.Lock()
defer s.mtx.Unlock()
return s.rws.Close()
}
func labelsToEqualityMatchers(ls model.LabelSet) []*labels.Matcher {
ms := make([]*labels.Matcher, 0, len(ls))
for k, v := range ls {
ms = append(ms, &labels.Matcher{
Type: labels.MatchEqual,
Name: string(k),
Value: string(v),
})
}
return ms
}
// Used for hashing configs and diff'ing hashes in ApplyConfig.
func toHash(data interface{}) (string, error) {
bytes, err := yaml.Marshal(data)
if err != nil {
return "", err
}
hash := md5.Sum(bytes)
return hex.EncodeToString(hash[:]), nil
}
```
|
```go
// Code generated by go-swagger; DO NOT EDIT.
//
// path_to_url
//
// Unless required by applicable law or agreed to in writing, software
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//
package alert
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the generate command
import (
"net/http"
"github.com/go-openapi/runtime/middleware"
)
// PostAlertsHandlerFunc turns a function with the right signature into a post alerts handler
type PostAlertsHandlerFunc func(PostAlertsParams) middleware.Responder
// Handle executing the request and returning a response
func (fn PostAlertsHandlerFunc) Handle(params PostAlertsParams) middleware.Responder {
return fn(params)
}
// PostAlertsHandler interface for that can handle valid post alerts params
type PostAlertsHandler interface {
Handle(PostAlertsParams) middleware.Responder
}
// NewPostAlerts creates a new http.Handler for the post alerts operation
func NewPostAlerts(ctx *middleware.Context, handler PostAlertsHandler) *PostAlerts {
return &PostAlerts{Context: ctx, Handler: handler}
}
/*
PostAlerts swagger:route POST /alerts alert postAlerts
Create new Alerts
*/
type PostAlerts struct {
Context *middleware.Context
Handler PostAlertsHandler
}
func (o *PostAlerts) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
route, rCtx, _ := o.Context.RouteInfo(r)
if rCtx != nil {
*r = *rCtx
}
var Params = NewPostAlertsParams()
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
o.Context.Respond(rw, r, route.Produces, route, err)
return
}
res := o.Handler.Handle(Params) // actually handle the request
o.Context.Respond(rw, r, route.Produces, route, res)
}
```
|
```xml
import { useCallback, useMemo, useState } from 'react';
import { c } from 'ttag';
import { generateUID } from '@proton/components';
import { SupportedMimeTypes } from '@proton/shared/lib/drive/constants';
import type { TransferMeta } from '../../../components/TransferManager/transfer';
import { TransferState } from '../../../components/TransferManager/transfer';
import { isTransferFinished, isTransferPending } from '../../../utils/transfer';
import type { LinkDownload } from '../interface';
import type {
Download,
UpdateCallback,
UpdateCallbackParams,
UpdateData,
UpdateFilter,
UpdateState,
} from './interface';
import { DownloadUserError } from './interface';
type LogCallback = (id: string, message: string) => void;
export default function useDownloadQueue(log: LogCallback) {
const [downloads, setDownloads] = useState<Download[]>([]);
const hasDownloads = useMemo((): boolean => {
return downloads.length > 0;
}, [downloads]);
const nextDownload = useMemo(() => {
return downloads.find((download) => isTransferPending(download));
}, [downloads]);
const add = useCallback(async (links: LinkDownload[], options?: { virusScan?: boolean }): Promise<void> => {
return new Promise((resolve, reject) => {
setDownloads((downloads) => {
if (isAlreadyDownloading(downloads, links)) {
reject(new DownloadUserError(generateAlreadyDownloadingError(links)));
return downloads;
}
const download = generateDownload(links, options);
log(
download.id,
`Added item to the queue (type: ${download.meta.mimeType}, size: ${download.meta.size} bytes)`
);
resolve();
return [...downloads, download];
});
});
}, []);
const update = useCallback(
(
idOrFilter: UpdateFilter,
newStateOrCallback: UpdateState,
{ size, error, signatureIssueLink, signatureStatus, scanIssueError }: UpdateData = {},
callback?: UpdateCallback
) => {
const filter = convertFilterToFunction(idOrFilter);
const newStateCallback = convertNewStateToFunction(newStateOrCallback);
const updateDownload = (download: Download): Download => {
if (filter(download)) {
callback?.(download);
const newState = newStateCallback(download);
// If pause is set twice, prefer resumeState set already before
// to not be locked in paused state forever.
download.resumeState =
newState === TransferState.Paused ? download.resumeState || download.state : undefined;
download.state = newState;
if (size !== undefined) {
download.meta.size = size;
}
download.error = error;
download.signatureIssueLink = signatureIssueLink;
download.signatureStatus = signatureStatus;
download.scanIssueError = scanIssueError;
log(
download.id,
`Updated queue (state: ${newState} ${size !== undefined ? `, size: ${size}` : ''} ${error ? `, error: ${error}` : ''})`
);
}
return download;
};
setDownloads((downloads) => [...downloads.map(updateDownload)]);
},
[]
);
const updateState = useCallback(
(idOrFilter: UpdateFilter, newStateOrCallback: UpdateState) => {
update(idOrFilter, newStateOrCallback);
},
[update]
);
const updateWithData = useCallback(
(idOrFilter: UpdateFilter, newStateOrCallback: UpdateState, data: UpdateData = {}) => {
update(idOrFilter, newStateOrCallback, data);
},
[update]
);
const updateWithCallback = useCallback(
(idOrFilter: UpdateFilter, newStateOrCallback: UpdateState, callback: UpdateCallback) => {
update(idOrFilter, newStateOrCallback, {}, callback);
},
[update]
);
const remove = useCallback((idOrFilter: UpdateFilter, callback?: UpdateCallback) => {
const filter = convertFilterToFunction(idOrFilter);
const invertFilter: UpdateFilter = (item) => !filter(item);
setDownloads((downloads) => {
if (callback) {
downloads.filter(filter).forEach((download) => callback(download));
}
return [...downloads.filter(invertFilter)];
});
}, []);
const clear = useCallback(() => {
setDownloads([]);
}, []);
return {
downloads,
hasDownloads,
nextDownload,
add,
updateState,
updateWithData,
updateWithCallback,
remove,
clear,
};
}
export function convertFilterToFunction(filterOrId: UpdateFilter) {
return typeof filterOrId === 'function' ? filterOrId : ({ id }: UpdateCallbackParams) => id === filterOrId;
}
function convertNewStateToFunction(newStateOrCallback: UpdateState) {
return typeof newStateOrCallback === 'function' ? newStateOrCallback : () => newStateOrCallback;
}
function isAlreadyDownloading(downloads: Download[], links: LinkDownload[]): boolean {
return downloads.some((download) => {
// User can download the same files again after previous one was
// already finished, either canceled, failed, or downloaded.
if (isTransferFinished(download)) {
return false;
}
if (download.links.length !== links.length) {
return false;
}
const ids = download.links.map((link) => link.shareId + link.linkId);
return links.every((link) => ids.includes(link.shareId + link.linkId));
});
}
function generateAlreadyDownloadingError(links: LinkDownload[]): string {
if (links.length > 1) {
return c('Error').t`File selection is already downloading`;
}
const { name } = links[0];
if (!links[0].isFile) {
return c('Error').t`Folder "${name}" is already downloading`;
}
return c('Error').t`File "${name}" is already downloading`;
}
function generateDownload(links: LinkDownload[], options?: { virusScan?: boolean }): Download {
return {
id: generateUID(),
startDate: new Date(),
state: TransferState.Pending,
links,
meta: generateDownloadMeta(links),
options,
};
}
function generateDownloadMeta(links: LinkDownload[]): TransferMeta {
if (links.length === 1) {
const link = links[0];
if (link.isFile) {
return {
filename: link.name,
mimeType: link.mimeType,
size: link.size,
};
}
return {
filename: `${link.name}.zip`,
mimeType: SupportedMimeTypes.zip,
};
}
return {
filename: generateMyFilesName(),
mimeType: SupportedMimeTypes.zip,
};
}
function generateMyFilesName(): string {
const date = new Date().toISOString().substring(0, 19);
// translator: Name of the download archive when selected multiple files, example: My files 2021-10-11T12:13:14.zip.
return c('Title').t`Download ${date}`.concat('.zip');
}
```
|
Mustafa Hamed Mohamed (October 17, 1959 in Melilla, Spain), better known as Mustafa Aberchán after his Riffian clan name, is a Spanish politician from Melilla. He is the leader of the political organization Coalition for Melilla.
He was the Mayor-President of the city from July 5, 1999, to July 19, 2000, with backing from the Spanish Socialist Workers' Party and the Independent Liberal Group, which made him the first Muslim to hold this position.
References
1959 births
Living people
Mayor-Presidents of Melilla
Members of the Assembly of Melilla
Coalition for Melilla politicians
Spanish people of Moroccan-Berber descent
Spanish Berber politicians
Spanish Muslims
People from Melilla
|
Clara Brink Shoemaker (20 June 1921 in Rolde - 30 September 2009) was a Dutch-born American crystallographer and a senior research professor at Oregon State University. As a postdoctoral researcher, she worked on the structure determination of vitamin B12 in the group of Dorothy Hodgkin. Together with her husband, David Shoemaker, she contributed to the research on transition metal phases and intermetallic compounds. They were the first to recognize that interstices in tetrahedrally close-packed metal crystals are exclusively tetrahedral and only have four types of coordination polyhedra.
Life
In 1941, Shoemaker completed her undergraduate degree at the University of Leiden which was closed shortly after due to the Nazi occupation. She then started her graduate studies at the University of Utrecht where she studied under Anton Eduard van Arkel. At the end of the World War II, she completed her doctoral examination. Afterwards, Shoemaker assumed an assistantship at the University of Utrecht and she learned the techniques of X-ray crystallography under the renowned crystallographer Caroline MacGillavry. In 1950, Shoemaker received her PhD from the University of Utrecht and was hired by Anton Eduard van Arkel as an X-ray crystallographer at the University of Leiden. During this time, her research focused on crystal structures of monovalent ions. Starting later in 1950, she worked on the crystal structure of vitamin B12 in Dorothy Hodgkin's laboratory in Oxford for one year. This resulted in three publications co-authored with Hodgkin. The stay was funded by an International Federation of University Women fellowship. In 1953, Shoemaker took a one-year leave of absence and travelled to Massachusetts Institute of Technology to work with David Shoemaker on the structure of transition metals. David Shoemaker renewed her leave of absence contract for another year in 1954. In 1955, Clara Brink Shoemaker and David Shoemaker married. After the wedding, Clara Shoemaker moved to Barbara Low's laboratory at Harvard Medical School. In 1956, her son Robert was born. While taking care of her son, Shoemaker worked from home on the International Tables of Crystallography. In 1959, Shoemaker became a naturalized citizen of the United States of America. Clara and David Shoemaker relocated to Oregon State University in 1970, where David Shoemaker was hired as a chairman and professor of chemistry. Due to the nepotism guidelines of the university, Clara Shoemaker worked as a research associate under Kenneth Hedberg whereas Hedberg's wife Lise Hedberg worked under David Shoemaker. In 1982, Clara Shoemaker was promoted to senior research professor. In 1984, both Clara and David Shoemaker retired from Oregon State University but continued their scientific work.
Research
Together with her husband, David Shoemaker she contributed to the research on transition metal phases and intermetallic compounds. They were the first to recognize that interstices in tetrahedrally close-packed metal crystals are exclusively tetrahedral and only have four types of coordination polyhedra.
Selected publications
Together with Dorothy Hodgkin, she published 3 publications on the crystal structure of vitamin B12:
References
1921 births
2009 deaths
American women chemists
American crystallographers
Dutch emigrants to the United States
People from Aa en Hunze
Leiden University alumni
Utrecht University alumni
Oregon State University faculty
20th-century American chemists
20th-century American women scientists
|
Santa Rose Church may refer to:
Santa Rosa Church, Florence, a church in Florence, Italy
Santa Rosa Church, Paramaribo, a church in Paramaribo, Suriname
|
Phil Defer is a Lucky Luke adventure in French, written and illustrated by Morris. It was the eighth title in the original series and was published by Dupuis in 1956 and in English by Cinebook in 2013 as Phil Wire. The album contains two stories - Lucky Luke contre Phil Defer "the Faucheux" ("Lucky Luke versus Phil Wire 'The Spider'") and Lucky Luke et Pilule ("Lucky Luke and Pill").
Stories
Lucky Luke contre Phil Defer
Synopsis
In the town of Bottleneck Gulch, the only saloon for miles around is the "Ace of Spades". It belongs to a crook, O'Sullivan, who sells adulterated whiskey. But as it is the only bar in the area, "Ace of Spades" does good business thanks to thirsty cowboys passing by. But one day, a certain O'Hara opens his own "Ace of Hearts" saloon.
Failing to take over his rival and being on the verge of bankruptcy, O'Sullivan decides to hire a professional hitman, Phil Wire, to rid him of O'Hara, dead or alive. Lucky Luke, who is a friend of O'Hara, decides to impersonate Phil Wire. With O'Hara, they put on a production to make believe the death of Phil Wire. As O'Sullivan prepares to leave, the real Phil Wire arrives in town. Together, they try by all means to get rid of Luke and O'Hara. But Lucky Luke is watching. Finally, Phil Wire provokes Lucky Luke into a final duel. Lucky Luke wins the duel and shoots Phil Defer on the shoulder which will end his career as a hitman. Because of this injury, Phil can no longer use a weapon. Afterwards, O'Sullivan is chased away. O'Hara takes his rival's saloon and unites it with his to form the "2 Aces Saloon" (spades and hearts), with "the longest bar in the west".
Characters
O'Sullivan: Owner of the Ace of Spades saloon. Sells adulterated whiskey to his customers and has no qualms about making money dishonestly. Does not tolerate any competition.
O'Hara: Owner of the Ace of Hearts saloon which he had built adjoining Ace of Spades. O'Sullivan then declares war on him.
Phil Wire: Nicknamed "The Spider". Professional shooter and hitman, he was hired by O'Sullivan to close the Ace of Hearts. He will discover in Lucky Luke an adversary to his measure.
Lucky Luke et Pilule
Synopsis
Lucky Luke tells other cowboys the story of a little man nicknamed Pill (because he regularly consumes pills) and who looked like a weed from big cities and who had, at first sight, nothing of a hero of the West. He arrives in a city infested by criminals and revolver fights, "Smokey Town". After having contributed (involuntarily) to the arrest of a bandit, Pill is named Sheriff. Thereafter, Pill must arrest the whole gang of criminals. Luckily, his clumsiness and myopia (having had lost his glasses at that time) which made him deviate from the target he was aiming at, help Pill to kill all the criminals. The gang leader almost killed him, but the bullet was stopped by the pill box the Sheriff was carrying.
Characters
Pill: This insignificant-looking character manages to pacify Smokey Town with incredible luck.
Lefty: Leader of a gang of mobsters in Smokey Town.
Notes
The look of Phil Defer was apparently inspired by the character of Jack Wilson in the film Shane. Played by Jack Palance, his remarkable postures (arched legs, arched back) made him a villain who greatly impressed Morris.
This album is one of the few Lucky Luke albums that have been censored. At the end of the original serialized publication in Le Moustique, Phil Wire is shot dead by Lucky Luke. This part was censored to make way for a scenario where he was only injured and made permanently unable to use a weapon.
The original version was used as a plot reference in the hommage story Lucky Luke: Wanted (2021), in which Wire's son Brad comes hunting for Luke to avenge his father.
Phil Wire's name in French is word play on the word 'iron wire' (fil de fer).
External links
Official Website
Comics by Morris (cartoonist)
Lucky Luke albums
1956 graphic novels
Works originally published in Spirou (magazine)
Works about contract killers
Censored comics
|
```javascript
import gml from "highlight.js/lib/languages/gml";
export default gml;
```
|
The Prince Charles stream tree frog (Hyloscirtus princecharlesi) is a species of frogs in the family Hylidae found in Ecuador. It is considered an endangered species threatened by habitat loss, climate change, pathogens, and other hazards.
In June 2012, the species was described as new to science by Luis A. Coloma et al. in the journal Zootaxa and named in honour of Charles III, King of the United Kingdom, recognising the then-Prince's work advocating rainforest conservation.
Taxonomy
An individual in the species was discovered by Luis Coloma in a museum specimen in 2008. Coloma was later part of an expedition in the Cotacachi Cayapas Ecological Reserve that found small numbers of the frogs, likely due to deforestation. The Amphibian Ark raised several frogs, hoping to boost the endangered population.
Distribution
The frog is endemic to Ecuador, and found only in the northeast, in the Cordillera de Toisán, in Imbabura Province. They're found between 2720 and 2794 meters above sea level, in the tierra fría zone.
Cultural importance
Its name is a patronymic that honors King Charles III, for his rainforest conservation work, such as the 2007 Prince's Rainforests Project, and as head of the UK World Wildlife Fund. In all his campaigns, he has used frogs as a symbol of the rainforest, and been affectionately called the "Frog Prince".
References
Hyloscirtus
Amphibians described in 2012
Charles III
|
```objective-c
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
==============================================================================*/
#ifndef TENSORFLOW_GRAPPLER_CLUSTERS_VIRTUAL_CLUSTER_H_
#define TENSORFLOW_GRAPPLER_CLUSTERS_VIRTUAL_CLUSTER_H_
#include <unordered_map>
#include "tensorflow/core/grappler/clusters/cluster.h"
#include "tensorflow/core/grappler/costs/op_level_cost_estimator.h"
#include "tensorflow/core/protobuf/device_properties.pb.h"
namespace tensorflow {
namespace grappler {
// Create a simple cluster that lists the devices (and their properties)
// available in a TensorFlow session. This cluster simulates the execution of
// actual graphs.
class VirtualCluster : public Cluster {
public:
VirtualCluster(const std::unordered_map<string, DeviceProperties>& devices);
VirtualCluster(const std::unordered_map<string, DeviceProperties>& devices,
OpLevelCostEstimator* node_estimator);
~VirtualCluster() override;
Status Provision() override;
Status Initialize(const GrapplerItem& item) override;
Status Run(const GraphDef& item,
const std::vector<std::pair<string, Tensor>>& feed,
const std::vector<string>& fetch, RunMetadata* metadata) override;
private:
std::unique_ptr<OpLevelCostEstimator> node_estimator_;
};
} // end namespace grappler
} // end namespace tensorflow
#endif // TENSORFLOW_GRAPPLER_CLUSTERS_VIRTUAL_CLUSTER_H_
```
|
```xml
export const CONTRIBUTIONTYPE = {
PERSON: 'person',
TEAM: 'team',
};
export const TEAMGOALTYPE = {
DEPARTMENT: 'Departments',
BRANCH: 'Branches',
};
export const GOALTYPECHOOSE = {
WON: 'Won (Deal based only)',
};
```
|
```vue
<template>
<div class="md-layout md-gutter">
<div class="md-layout-item">
<md-field>
<label for="food">Food</label>
<md-select v-model="food1" name="food" id="food">
<md-optgroup label="Baked Goods">
<md-option value="apple-pie">Apple Pie</md-option>
<md-option value="chocolate-cake">Chocolate Cake</md-option>
</md-optgroup>
<md-optgroup label="Fruits">
<md-option value="apples">Apples</md-option>
<md-option value="bananas">Bananas</md-option>
<md-option value="oranges">Oranges</md-option>
<md-option value="peaches">Peaches</md-option>
</md-optgroup>
<md-optgroup label="Vegetables">
<md-option value="broccoli">Broccoli</md-option>
<md-option value="carrots">Carrots</md-option>
<md-option value="cucumbers">Cucumbers</md-option>
</md-optgroup>
</md-select>
</md-field>
</div>
<div class="md-layout-item">
<md-field>
<label for="food">Food</label>
<md-select v-model="food2" name="food" id="food" md-dense>
<md-optgroup label="Baked Goods">
<md-option value="apple-pie">Apple Pie</md-option>
<md-option value="chocolate-cake">Chocolate Cake</md-option>
</md-optgroup>
<md-optgroup label="Fruits">
<md-option value="apples">Apples</md-option>
<md-option value="bananas">Bananas</md-option>
<md-option value="oranges">Oranges</md-option>
<md-option value="peaches">Peaches</md-option>
</md-optgroup>
<md-optgroup label="Vegetables">
<md-option value="broccoli">Broccoli</md-option>
<md-option value="carrots">Carrots</md-option>
<md-option value="cucumbers">Cucumbers</md-option>
</md-optgroup>
</md-select>
</md-field>
</div>
</div>
</template>
<script>
export default {
name: 'OptgroupSelect',
data: () => ({
food1: null,
food2: 'carrots'
})
}
</script>
```
|
```java
//
//
// path_to_url
//
// Unless required by applicable law or agreed to in writing, software
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package google.registry.proxy.metric;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.monitoring.metrics.EventMetric;
import com.google.monitoring.metrics.IncrementableMetric;
import com.google.monitoring.metrics.Metric;
import com.google.monitoring.metrics.MetricRegistryImpl;
import google.registry.util.NonFinalForTesting;
import io.netty.channel.Channel;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.joda.time.Duration;
/** Frontend metrics instrumentation. */
@Singleton
public class FrontendMetrics extends BaseMetrics {
private static final ConcurrentMap<ImmutableList<String>, ChannelGroup> activeConnections =
new ConcurrentHashMap<>();
static final Metric<Long> activeConnectionsGauge =
MetricRegistryImpl.getDefault()
.newGauge(
"/proxy/frontend/active_connections",
"Number of active connections from clients to the proxy.",
"Active Connections",
LABELS,
() ->
activeConnections.entrySet().stream()
.collect(
ImmutableMap.toImmutableMap(
Map.Entry::getKey, entry -> (long) entry.getValue().size())),
Long.class);
static final IncrementableMetric totalConnectionsCounter =
MetricRegistryImpl.getDefault()
.newIncrementableMetric(
"/proxy/frontend/total_connections",
"Total number connections ever made from clients to the proxy.",
"Total Connections",
LABELS);
static final IncrementableMetric quotaRejectionsCounter =
MetricRegistryImpl.getDefault()
.newIncrementableMetric(
"/proxy/frontend/quota_rejections",
"Total number rejected quota request made by proxy for each connection.",
"Quota Rejections",
LABELS);
static final EventMetric latencyMs =
MetricRegistryImpl.getDefault()
.newEventMetric(
"/proxy/frontend/latency_ms",
"Round-trip time between a request received and its corresponding response is sent.",
"Latency Milliseconds",
LABELS,
DEFAULT_LATENCY_FITTER);
@Inject
public FrontendMetrics() {}
@Override
void resetMetrics() {
totalConnectionsCounter.reset();
activeConnections.clear();
latencyMs.reset();
}
@NonFinalForTesting
public void registerActiveConnection(String protocol, String certHash, Channel channel) {
totalConnectionsCounter.increment(protocol, certHash);
ImmutableList<String> labels = ImmutableList.of(protocol, certHash);
ChannelGroup channelGroup;
if (activeConnections.containsKey(labels)) {
channelGroup = activeConnections.get(labels);
} else {
channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
activeConnections.put(labels, channelGroup);
}
channelGroup.add(channel);
}
@NonFinalForTesting
public void registerQuotaRejection(String protocol, String certHash) {
quotaRejectionsCounter.increment(protocol, certHash);
}
@NonFinalForTesting
public void responseSent(String protocol, String certHash, Duration latency) {
latencyMs.record(latency.getMillis(), protocol, certHash);
}
}
```
|
```java
/*
*
*
* 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.
*/
package me.lucko.luckperms.common.event;
import net.luckperms.api.event.EventBus;
import net.luckperms.api.event.LuckPermsEvent;
/**
* Defines a class which listens to {@link LuckPermsEvent}s.
*/
public interface LuckPermsEventListener {
void bind(EventBus bus);
}
```
|
Rikitea is a small town on Mangareva, which is part of the Gambier Islands in French Polynesia. A majority of the islanders live in Rikitea. The island was a protectorate of France in 1871 and was annexed in 1881.
History
The town's history dates to the era when the island was first settled with people from the Marquesas Islands in 1100 AD. Captain James Wilson of the London Missionary Society arrived in 1797 on Duff, naming the islands after the English Admiral James Gambier who had facilitated his expedition.
Before the Catholic missionaries' arrival, cannibalism was practiced under the rule of the local kings. French Picpus priests Father François Caret and Father Honoré Laval, of the Congregation for the Sacred Hearts, landed here in 1834. They arrived from Chile. Father Hippolyte Roussel, who had arrived at Rikitea with more than 100 Rapa Nui people on 4 July 1871, assumed charge of Laval's Rikitea mission, and served there till he died in 1898.
The figure of 9,000, mentioned by some, when Laval arrived is regarded as being hugely exaggerated. In 1825, the population was estimated at 1500. When the missionaries arrived in 1834 they counted 2,124 souls. Increasing contact with the outside world brought contagious diseases to Mangareva savagely decimating the population. There had already been several major epidemics before 1863, including one which is said have killed half the population.
The story about Laval driving the population to their deaths was spread by a French judge, Louis Jacolliot, who dabbled in the occult and had a grudge against Laval and wanted to discredit him. For 9,000 people to have lived on the islands, many would have to live on the hillsides due to the small amount of flat ground, but there is no evidence of houses ever being built there. Also, if 8,500 people died because of Laval, there would be that number of graves, or at least mass graves, but there is not.
Geography
Rikitea is a port town and tourist center situated on Mangareva Lagoon, which contains a number of motu. It is about southeast of Tahiti, to the North of the Tropic of Capricorn. The average elevation of the town is .
The total population of the island was 1100 and most of them lived in Rikitea.
Two mountains, Mt. Duff () and Mt. Mokoto (), which are approachable by trails, are north of the town. The climb to Duff's peak takes about 90 minutes. The stones found on the hill were used by the ethnic Mangarevans to predict weather and to look for boats headed for the island. The mountain is covered with tall aeho grass.
Economy
Black pearls are cultured on numerous platforms on both sides of the Mangareva lagoon. The lagoon is full of corals and black-lipped oysters are harvested by the people. The inhabitants are also involved in agriculture and fishing to the minimum level. The church is involved in technical school (CED, "Center for Educational Development) to train people in skill trades such as carpentry, mechanics, electricity, and mother-of-pearl shell engraving.
Landmarks
Father Honoré Laval built 116 stone buildings and arches, and roads were laid. Buildings included a fortified palace with follies as well as St. Michael's Cathedral which has also been characterized as a folly. The structures were built with shaped coral stone blocks. Several of the structures dating to Laval's time still remain, such as the watch towers on the coast and a turret, the remains of the palace built for Maputeoa, the last king of the island. King Maputeoa's crypt is in the St. Pierre's Chapel behind the neo-Gothic St. Michael's Cathedral.
The Couvent Rouru (Rouru Convent), near the southern end of the cemetery, is now in ruins, but housed 60 nuns at one time. There is a carving school near the cathedral at Camika CED which features mother of pearl carvings. Here training is provided in the art of shell engraving. Pendants and barrettes created here can be purchased at the centre's sales outlet. Riktea has a large nuclear fall-out shelter which was built at the time of the French atmospheric testing at Moruroa.
The town also has post office, a few shops, a military establishment, a medical room, and schools. Accommodation of note includes Chez Pierre et Mariette near the wharf, with three rooms, and Pension Bianca et Benoit, in the southern part of the town.
Transportation
The town is accessed by air and by ship. The airport is located on Mou Totegegie, NorthEast. From the airport, boats provide the only access to Rikitea. Flights operate from Pape'ete and take four and half hours. Travel by ship originates only from Pape'ete, a journey of 21 days, with stops at four other islands before arriving at the Rikitea. A road circles the entire island.
References
Bibliography
External links
Mangareva
Geography of the Gambier Islands
Populated places in French Polynesia
|
Michael Joseph Pazik (born January 26, 1950) is an American former Major League Baseball pitcher. He pitched parts of three seasons in the majors, from until , for the Minnesota Twins.
Amateur career
A native of Lynn, Massachusetts, Pazik graduated from Lynn English High School in 1968, and was selected by the Los Angeles Dodgers in the 4th round of the 1968 MLB Draft. He opted to play college baseball at the College of the Holy Cross. In 1968 and 1969, Pazik played collegiate summer baseball with the Harwich Mariners of the Cape Cod Baseball League (CCBL) and was named a league all-star in 1969. He returned to the CCBL in 1970 and 1971 to play for the Orleans Cardinals, tossing a no-hitter in 1971.
Professional career
Pazik was selected by the New York Yankees in the first round of the 1971 MLB Draft. He played for the Yankees' minor league affiliate Syracuse Chiefs for several seasons before being traded to the Minnesota Twins for Dick Woodson in 1974. He made his big league debut for Minnesota in 1975, and pitched a total of 46.2 innings for the Twins over three seasons. Pazik signed as a free agent with the Chicago White Sox in 1978, and played two seasons in Chicago's minor league system, but was not recalled to the majors.
Coaching and scouting career
After his playing career, Pazik was a minor league coach and manager, including serving as the pitching coach for the Chicago White Sox from until . He also served as a scout for Kansas City Royals during their 2015 World Series winning season.
Personal life
Mike's daughter, Kristen Pazik, is a model who is married to Ukrainian former soccer player turned manager Andriy Shevchenko.
References
External links
, or Retrosheet
1950 births
Living people
American people of Polish descent
Baseball players from Lynn, Massachusetts
Chicago White Sox coaches
Chicago White Sox scouts
College of the Holy Cross alumni
Fort Lauderdale Yankees players
Harwich Mariners players
Holy Cross Crusaders baseball players
Iowa Oaks players
Kansas City Royals scouts
Knoxville Sox players
Major League Baseball pitchers
Major League Baseball pitching coaches
Minnesota Twins players
Minor league baseball coaches
Minor league baseball managers
Orleans Firebirds players
Petroleros de Zulia players
Portland Beavers players
Syracuse Chiefs players
Tacoma Twins players
Tigres de Aragua players
American expatriate baseball players in Venezuela
|
```c++
/// Source : path_to_url
/// Author : liuyubobobo
/// Time : 2021-02-23
#include <iostream>
#include <vector>
using namespace std;
/// Brute Force
/// Time Complexity: O(R * C)
/// Space Complexity: O(1)
class Solution {
public:
vector<vector<int>> flipAndInvertImage(vector<vector<int>>& A) {
int R = A.size();
if(R == 0) return A;
int C = A[0].size();
if(C == 0) return A;
for(int i = 0; i < R; i ++){
int l = 0, r = C - 1;
while(l < r) swap(A[i][l ++], A[i][r --]);
for(int& e: A[i]) e = !e;
}
return A;
}
};
int main() {
return 0;
}
```
|
Abdiweli Ibrahim Sheikh Muudey is a Somali politician. He is the former Minister of Labour of Somalia, having been appointed to the position on 6 February 2015 by former Prime Minister Omar Abdirashid Ali Sharmarke. He has now been succeeded by Salah Ahmed Jama.
References
Living people
Government ministers of Somalia
Year of birth missing (living people)
|
John O'Brien (born 3 January 1982) is an Irish hurler who played as a centre-forward for the Tipperary senior team.
Born in Toomevara, County Tipperary, O'Brien first arrived on the inter-county scene at the age of seventeen when he first linked up with the Tipperary minor team, before later joining the under-21 side. He made his senior debut during the 2001 league. O'Brien went on to enjoy a lengthy career, and won two All-Ireland medals, five Munster medals and one National Hurling League medals. He was an All-Ireland runner-up on three occasions.
At club level O'Brien is a two-time Munster medallist with Toomevara. In addition to this he has also won seven championship medals and three county final Man of the Match awards.
His brother, Paddy O'Brien, is also an All-Ireland medallist with Tipperary.
Throughout his career O'Brien made 36 championship appearances. He announced his retirement from inter-county hurling on 26 November 2014.
Playing career
Club
O'Brien plays his club hurling with Toomevara and has enjoyed much success in a lengthy career.
After making his senior championship debut as a seventeen-year-old in 1999, Toomevara went on to qualify for a second successive county final. A 1-17 to 0-13 defeat of Nenagh Éire Óg gave O'Brien his first championship medal.
Toomevara's championship dominance continued for a third consecutive year in 2000. A 2-10 to 0-11 defeat of Thurles Sarsfield's gave O'Brien his second championship medal.
Both Toomevara and Thurles Sarsfield's met in the county final again in 2001. O'Brien's side were on the verge of history by becoming the third side in history to win four championships in-a-row. A 1-22 to 1-13 trouncing of the Thurles club gave O'Brien his third championship medal.
Five-in-a-row proved beyond Toomevara, however, the team reached the county final once again in 2003. A 3-16 to 3-13 defeat of Thurles Sarsfield's once again, gave O'Brien his fourth championship medal.
Toomevara retained their title in 2004 following a comfortable 4-12 to 2-12 win over Éire Óg/Golden. It was also a remarkable fifth championship medal in six seasons for O'Brien. After a number of early exits from the provincial championship in recent years, Toomevara subsequently defeated Mount Sion by just a single point to give O'Brien his first Munster medal.
After surrendering their county and provincial titles in 2005, Toomevara returned to the county championship decider once again the following year. A thrilling 1-21 to 2-14 defeat of Nenagh Éire Óg, in which O'Brien top scored with 1-4 from play, saw Toomevara take the title once again. O'Brien later won a second Munster medal following a controversial 2-9 to 2-8 defeat of Erin's Own of Cork.
In 2008 O'Brien won a seventh county championship medal following a 2-14 to 0-17 defeat of old rivals Thurles Sarsfield's.
Minor & under-21
O'Brien was seventeen-years-old when he made his minor championship debut for Tipperary in 1999. He collected his first Munster medal that year following a 1–13 to 2-7 defeat of Clare. Tipp progressed to the All-Ireland final where Galway provided the opposition. A 0–13 to 0–10 score line resulted in defeat for O'Brien's side.
In 2003 O'Brien was in his last year as a member of the under-21 team. That year Tipperary broke through Limerick's stranglehold on the championship and O'Brien secured a Munster medal following a 2-14 to 0-17 defeat of Cork after extra-time.
Senior
Beginnings
O'Brien made his senior debut on 21 April 2001 in a 1-16 to 0-13 group stage defeat of Laois in the National League. Tipperary later claimed the league title, however, O'Brien remained as a substitute for that victory. Later that year he made his championship debut when he came on as substitute for Lar Corbett in the provincial decider against Limerick. Tipperary triumphed by 2-16 to 1-17, with O'Brien collecting his first Munster medal. He later collected an All-Ireland medal as a non-playing substitute as Tipperary defeated Galway by 2-18 to 2-15.
Over the next few years O'Brien remained on the periphery of the team as Tipperary went into decline.
Return to success
The appointment of Liam Sheedy as Tipperary's new manager saw O'Brien take to a more prominent role. Tipperary remained undefeated during their 2008 league campaign and qualified for the decider against Galway. A Lar Corbett goal proved decisive in the 3-18 to 3-16 victory. It was O'Brien's first National League medal on the field of play. He later collected a second Munster medal as Tipperary continued their winning streak with a 2-21 to 0-19 defeat of a resurgent Clare. After scoring 1-4 in that game he was named man of the match.
Tipperary retained their provincial crown in 2009, with O'Brien collecting a third Munster medal following a 4-14 to 2-16 defeat of Waterford. On 6 September 2009 Tipperary faced four-in-a-row hopefuls Kilkenny in the All-Ireland decider. For long periods Tipp looked the likely winners, however, late goals from Henry Shefflin and substitute Martin Comerford finally killed off their efforts to secure a 2-22 to 0-23 victory.
Three successive Munster titles proved beyond Tipperary, however, in spite of a shock defeat by Cork in the provincial quarter-final, Tipperary used the qualifiers to good effect and qualified for the All-Ireland decider on 5 September 2010. Kilkenny were the opponents once again as they sought a fifth successive All-Ireland crown title. "The Cats" lost talisman Henry Shefflin early in the game due to injury, while Tipp's Lar Corbett ran riot and scored a hat-trick of goals before Noel McGrath added a fourth. The 4-17 to 1-18 victory gave O'Brien his first All-Ireland medal on the field of play.
Tipperary reclaimed the provincial crown in 2011 following a huge 7-19 to 0-19 drubbing of Waterford in the decider. It was O'Brien's fourth Munster medal. Tipperary subsequently faced Kilkenny in a third successive All-Ireland decider on 4 September 2011. Goals by Michael Fennelly and Richie Hogan in either half gave Kilkenny, who many viewed as the underdogs going into the game, a 2-17 to 1-16 victory.
Final years
Tipperary won their fourth Munster crown in five years in 2012 as they easily retained the title. The 2-17 to 0-16 defeat of Waterford gave O'Brien a fifth provincial winners' medal.
After a poor start to their 2014 championship campaign, Tipperary reached the All-Ireland final on 7 September 2014. O'Brien started the game on the bench but was introduced as a substitute in what some consider to be the greatest game of all-time. John O'Dwyer had the chance to win the game, however, his late free drifted wide resulting in a draw. O'Brien was also sprung from the bench in the replay which Kilkenny won by 2-17 to 2-14.
O'Brien announced his retirement from inter-county hurling on 26 November 2014. In a released statement he said "I wish to announce my retirement from the Tipperary Hurling team. It has been an honour to have represented my county at senior level since my debut in 2001. I would like to thank everyone who has supported me and made it possible for me to play, most importantly my family and friends, my club Toomevara, the management and backroom teams throughout those years which are too many to mention and also the Tipperary public. I have made many great friends over those years and I would like to wish the current panel and management team the very best of luck."
Honours
Team
Toomevara
Munster Senior Club Hurling Championship (2): 2004, 2006
Tipperary Senior Club Hurling Championship (7): 1999, 2000, 2001, 2003, 2004, 2006, 2008
Tipperary
All-Ireland Senior Hurling Championship (2): 2001, 2010
Munster Senior Hurling Championship (5): 2001, 2008, 2009, 2011, 2012
National Hurling League (1): 2008
Munster Under-21 Hurling Championship (1): 2003
Munster Minor Hurling Championship (1): 1999
References
1982 births
Living people
Tipperary inter-county hurlers
Toomevara hurlers
All-Ireland Senior Hurling Championship winners
|
The Batterie de Bouviers is located in the commune of Guyancourt, Yvelines, France. It is a former fortification built beginning in 1879 and occupied by the army until 1932. From 1933 it was leased by the Hispano Suiza company as a factory, surrounded by other industrial structures. The site was abandoned by Hispano Suiza in 1990, and was sold by the Ministry of Defense in 1999. In 2006 the battery became the "Cafe Musiques", surrounded by office buildings and a music school.
History
In 1870 France was partly occupied by the Prussian army. Following that defeat, France instituted the Séré de Rivières system of fortifications, with a new outer ring of fortifications to defend Paris from long-range artillery bombardment. 18 forts, five redoubts and 34 batteries were built between 1874 and 1881.
The Batterie de Bouviers was built between 1877 and 1879 as part of this project, near the village of Bouviers in the town of Guyancourt. Since the battery was built the town has expanded with the construction of the Saules neighborhood in the vicinity of the battery.
The Batterie de Bouviers was part of an ensemble comprising two forts, the Fort de Villeras in Saclay and the Fort du Haut-Buc, with five peripheral works: the Batterie de la Port du Désert (destroyed), the Batterie de la station de St-Cyr (partly destroyed), the Batterie du Ravin de Bouviers, the Ouvrage des Docks and the Batteries de Bouviers.
The Batterie du Ravin de Bouviers is of modest dimensions, and is therefore sometimes termed a redoubt. The similarity between the Battery/Redoubt du Ravin de Bouviers and the Batterie de Bouviers has given rise to confusion between the two positions.
The strategy for siting the various fortified positions was one of mutual support between fortifications, with converging fields of fire on enemy troops attempting to pass between fortifications. When conceived in the 1870s the fortifications were considered impregnable. However, the introduction of high-explosive shells capable of penetrating masonry made these positions obsolete almost as soon as they were completed.
Description
The principal battery, known as the caserne sous le parados (barracks under the entrance) is composed of gun chambers all oriented opening on the northeastern facade, with arched vaults expressed on the main wall as blind arches. Materials include limestone, millstone and brick. Concrete was added after 1879, and was retained in the 2006 renovation. A small bastion protects the entry from direct fire directly opposite the gate.
The military battery
The central portion of the battery is composed of rectangular units measuring by , vaulted, and separated from each other by sidewalls in depth, housing the casemates. Individual vaults are structurally independent of the others, preventing damage to one from affecting the others. The casemates are covered by soil up to thick in a trapezoidal mass, using material excavated from the battery's dry moat, which surrounds the position. The barracks are served by a corridor to the rear. Doors and windows were fitted with armored shutters, providing protection against shrapnel. Fittings for the shutters remain in place. Two caponiers covered the front of the battery on the far side of the ditch, and another covered the ditch to the rear. The ditch and caponiers have been destroyed, along with the powder magazines.
The gate is crowned with the inscription "Batterie de Bouviers" and "1879," with a relief of a mortar on the keystone. Rainwater was collected by gutters and channeled to cisterns under the battery, supporting at least 200 troops and 19 artillery pieces.
After the introduction of high explosive artillery shells, the fortifications became obsolete. The forts closest to the frontiers were modified, but the fortifications of Paris received little improvement due to financial restrictions.
Hispano Suiza
The battery was occupied by the military until 1932. From 1933 the battery was leased to Hispano Suiza who surrounded it with numerous industrial buildings, where the company made munitions. This caused friction with the local populace, which was until this time predominantly agricultural. Daily test firing caused further concern. At the beginning of World War II, the battery was bombarded and munitions production was relocated to the Charente. After the war work was confined to work on motors and turbines. The factory was closed in 1990 and sold by the Ministry of Defense in 1999.
Present use
The battery was transformed in 2006 to the "Café Musiques" and opened to the public. The architects were Ivan Franic and Michel Garcin with acoustician Maurice Auffret. Work was sponsored by Saint-Quentin-en-Yvelines. The cafe provides a proscenium stage and accommodations for 450 spectators, three rehearsal and recording studios, technical rooms, dressing rooms and administrative offices, with an adjoining cafe.
Work began on the music school in 2008, designed by architect Yann Brunel. The former industrial lands have been redeveloped. Sodexho France moved its headquarters to the development in 2009.
Gallery
See also
Séré de Rivières system
Fortifications of Paris in the 19th and 20th centuries
References
La Redoute de Bouviers et Hispano Suiza : Réhabilitation d'un bâtiment du patrimoine industriel, Fanny Dupont, IUP ASCM M1 A, April 2007.
External links
La Batterie official site
Batterie de Bouviers at Saint-Quentin-en-Yvelines
Fortifications of Paris
Séré de Rivières system
Artillery batteries
Buildings and structures in Yvelines
|
Neotiara rupicola is a species of sea snail, a marine gastropod mollusk, in the family Mitridae, the miters or miter snails.
References
rupicola
Gastropods described in 1844
|
Dunfanaghy Road railway station served the village of Dunfanaghy in County Donegal, Ireland.
The station opened on 9 March 1903 when the Londonderry and Lough Swilly Railway opened their Letterkenny and Burtonport Extension Railway, from Letterkenny to Burtonport. It closed on 3 June 1940 when the LLSR closed the line from Tooban Junction to Burtonport in an effort to save money.
Routes
References
Disused railway stations in County Donegal
Railway stations opened in 1903
Railway stations closed in 1940
1903 establishments in Ireland
1940 disestablishments in Ireland
Railway stations in the Republic of Ireland opened in the 1900s
Railway stations in the Republic of Ireland closed in 1940
|
```java
package com.yahoo.vespa.orchestrator.restapi.wire;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.List;
/**
* A list of references to applications.
*
* @author hakonhall
*/
@JsonIgnoreProperties(ignoreUnknown = true)
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ApplicationReferenceList {
@JsonProperty("applications")
public List<UrlReference> applicationList = List.of();
}
```
|
```java
The distinction between overloading and overriding methods
Generating random numbers
The trade-off between short and descriptive names
Java naming conventions
Updating interfaces by using `default` methods
```
|
Streptomyces koyangensis is a bacterium species from the genus of Streptomyces which has been isolated from radish soil in Koyang in Korea. Streptomyces koyangensis produces antifungal 4-phenyl-3-butenoic acid.
See also
List of Streptomyces species
References
Further reading
External links
Type strain of Streptomyces koyangensis at BacDive - the Bacterial Diversity Metadatabase
koyangensis
Bacteria described in 2005
|
Raymond J. Seigfried (born August 23, 1950) is an American politician. He was a Democratic member of the Delaware House of Representatives, representing District 7, from 2018 to 2020.
Seigfried is a professor of healthcare policy and worked as a senior vice president for Christiana Care for over 25 years.
In 2018, Seigfried topped four other Democrats in the primary election to replace retiring Democrat Bryon Short, winning 762 votes (28.7%) in the five-way race. He won the general election with 5,943 votes (62.9%) against Republican nominee Eric Braunstein and Libertarian nominee Scott Gesty. Seigfried lived on the same street as Braunstein.
In 2020, Seigfried was defeated in the Democratic primary in a rematch with the 2018 primary runner-up, progressive Larry Lambert, by a 59%-41% margin.
References
External links
Official page at the Delaware General Assembly
Campaign site
1950 births
Living people
Democratic Party members of the Delaware House of Representatives
21st-century American politicians
|
```python
"""Python wrappers around TensorFlow ops.
This file is MACHINE GENERATED! Do not edit.
Original C++ source file: decode_audio_op_py.cc
"""
import collections as _collections
from tensorflow.python.eager import execute as _execute
from tensorflow.python.eager import context as _context
from tensorflow.python.eager import core as _core
from tensorflow.python.framework import dtypes as _dtypes
from tensorflow.python.framework import tensor_shape as _tensor_shape
from tensorflow.core.framework import op_def_pb2 as _op_def_pb2
# Needed to trigger the call to _set_call_cpp_shape_fn.
from tensorflow.python.framework import common_shapes as _common_shapes
from tensorflow.python.framework import op_def_registry as _op_def_registry
from tensorflow.python.framework import ops as _ops
from tensorflow.python.framework import op_def_library as _op_def_library
def decode_audio(contents, file_format, samples_per_second, channel_count, name=None):
r"""Processes the contents of an audio file into a tensor using FFmpeg to decode
the file.
One row of the tensor is created for each channel in the audio file. Each
channel contains audio samples starting at the beginning of the audio and
having `1/samples_per_second` time between them. If the `channel_count` is
different from the contents of the file, channels will be merged or created.
Args:
contents: A `Tensor` of type `string`. The binary audio file contents.
file_format: A `string`.
A string describing the audio file format. This can be "mp3", "mp4", "ogg", or "wav".
samples_per_second: An `int`.
The number of samples per second that the audio should have.
channel_count: An `int`. The number of channels of audio to read.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `float32`.
A rank 2 tensor containing all tracks of the audio. Dimension 0
is time and dimension 1 is the channel. If ffmpeg fails to decode the audio
then an empty tensor will be returned.
"""
file_format = _execute.make_str(file_format, "file_format")
samples_per_second = _execute.make_int(samples_per_second, "samples_per_second")
channel_count = _execute.make_int(channel_count, "channel_count")
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper(
"DecodeAudio", contents=contents, file_format=file_format,
samples_per_second=samples_per_second, channel_count=channel_count,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = ("file_format", _op.get_attr("file_format"),
"samples_per_second", _op.get_attr("samples_per_second"),
"channel_count", _op.get_attr("channel_count"))
else:
contents = _ops.convert_to_tensor(contents, _dtypes.string)
_inputs_flat = [contents]
_attrs = ("file_format", file_format, "samples_per_second",
samples_per_second, "channel_count", channel_count)
_result = _execute.execute(b"DecodeAudio", 1, inputs=_inputs_flat,
attrs=_attrs, ctx=_ctx, name=name)
_execute.record_gradient(
"DecodeAudio", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def decode_audio_v2(contents, file_format, samples_per_second, channel_count, name=None):
r"""Processes the contents of an audio file into a tensor using FFmpeg to decode
the file.
One row of the tensor is created for each channel in the audio file. Each
channel contains audio samples starting at the beginning of the audio and
having `1/samples_per_second` time between them. If the `channel_count` is
different from the contents of the file, channels will be merged or created.
Args:
contents: A `Tensor` of type `string`.
The binary audio file contents, as a string or rank-0 string
tensor.
file_format: A `Tensor` of type `string`.
A string or rank-0 string tensor describing the audio file
format. This must be one of: "mp3", "mp4", "ogg", "wav".
samples_per_second: A `Tensor` of type `int32`.
The number of samples per second that the audio
should have, as an `int` or rank-0 `int32` tensor. This value must
be positive.
channel_count: A `Tensor` of type `int32`.
The number of channels of audio to read, as an int rank-0
int32 tensor. Must be a positive integer.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `float32`.
A rank-2 tensor containing all tracks of the audio.
Dimension 0 is time and dimension 1 is the channel. If ffmpeg fails
to decode the audio then an empty tensor will be returned.
"""
_ctx = _context.context()
if _ctx.in_graph_mode():
_, _, _op = _op_def_lib._apply_op_helper(
"DecodeAudioV2", contents=contents, file_format=file_format,
samples_per_second=samples_per_second, channel_count=channel_count,
name=name)
_result = _op.outputs[:]
_inputs_flat = _op.inputs
_attrs = None
else:
contents = _ops.convert_to_tensor(contents, _dtypes.string)
file_format = _ops.convert_to_tensor(file_format, _dtypes.string)
samples_per_second = _ops.convert_to_tensor(samples_per_second, _dtypes.int32)
channel_count = _ops.convert_to_tensor(channel_count, _dtypes.int32)
_inputs_flat = [contents, file_format, samples_per_second, channel_count]
_attrs = None
_result = _execute.execute(b"DecodeAudioV2", 1, inputs=_inputs_flat,
attrs=_attrs, ctx=_ctx, name=name)
_execute.record_gradient(
"DecodeAudioV2", _inputs_flat, _attrs, _result, name)
_result, = _result
return _result
def _InitOpDefLibrary(op_list_proto_bytes):
op_list = _op_def_pb2.OpList()
op_list.ParseFromString(op_list_proto_bytes)
_op_def_registry.register_op_list(op_list)
op_def_lib = _op_def_library.OpDefLibrary()
op_def_lib.add_op_list(op_list)
return op_def_lib
# op {
# name: "DecodeAudio"
# input_arg {
# name: "contents"
# type: DT_STRING
# }
# output_arg {
# name: "sampled_audio"
# type: DT_FLOAT
# }
# attr {
# name: "file_format"
# type: "string"
# }
# attr {
# name: "samples_per_second"
# type: "int"
# }
# attr {
# name: "channel_count"
# type: "int"
# }
# }
# op {
# name: "DecodeAudioV2"
# input_arg {
# name: "contents"
# type: DT_STRING
# }
# input_arg {
# name: "file_format"
# type: DT_STRING
# }
# input_arg {
# name: "samples_per_second"
# type: DT_INT32
# }
# input_arg {
# name: "channel_count"
# type: DT_INT32
# }
# output_arg {
# name: "sampled_audio"
# type: DT_FLOAT
# }
# }
_op_def_lib = _InitOpDefLibrary(b"\nv\n\013DecodeAudio\022\014\n\010contents\030\007\032\021\n\rsampled_audio\030\001\"\025\n\013file_format\022\006string\"\031\n\022samples_per_second\022\003int\"\024\n\rchannel_count\022\003int\nl\n\rDecodeAudioV2\022\014\n\010contents\030\007\022\017\n\013file_format\030\007\022\026\n\022samples_per_second\030\003\022\021\n\rchannel_count\030\003\032\021\n\rsampled_audio\030\001")
```
|
Adam Coleman Howard is an American actor, screenwriter and film director. He is the son of advice columnist Margo Howard, the grandson of advice columnist Ann Landers and the stepson of actor Ken Howard.
Filmography
Actor
Quiet Cool (1986, directed by Clay Borris) - Joshua Greer
Slaves of New York (1989, directed by James Ivory) - Stash
The Equalizer (TV series)
Suicide Squad (1989, directed by Marc Laub) - Willie Halsey (guest star)
Pacific Palisades (1990, directed by Bernard Schmitt, starring Sophie Marceau) - Ben
No Secrets (1991, directed by Dezsö Magyar) - Manny
Ride Me (1994, directed by Bashar Shbib) - Adolpho Frenzy
Dead Girl (1996, directed by Adam Coleman Howard) - Ari Rose
Writer and director
Dead Girl (1996) - starring Anne Parillaud, Val Kilmer and Seymour Cassel
Dark Harbor (1998) - starring Alan Rickman and Polly Walker
Associate producer
Refuge (2002, directed by Narain Jashanmal)
References
External links
American male film actors
American film directors
American male television actors
American male screenwriters
Year of birth missing (living people)
Living people
Place of birth missing (living people)
|
```objective-c
/*
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef FWSIGNAL_H_
#define FWSIGNAL_H_
struct brcmf_fws_info *brcmf_fws_attach(struct brcmf_pub *drvr);
void brcmf_fws_detach(struct brcmf_fws_info *fws);
bool brcmf_fws_queue_skbs(struct brcmf_fws_info *fws);
bool brcmf_fws_fc_active(struct brcmf_fws_info *fws);
void brcmf_fws_hdrpull(struct brcmf_if *ifp, s16 siglen, struct sk_buff *skb);
int brcmf_fws_process_skb(struct brcmf_if *ifp, struct sk_buff *skb);
void brcmf_fws_reset_interface(struct brcmf_if *ifp);
void brcmf_fws_add_interface(struct brcmf_if *ifp);
void brcmf_fws_del_interface(struct brcmf_if *ifp);
void brcmf_fws_bustxfail(struct brcmf_fws_info *fws, struct sk_buff *skb);
void brcmf_fws_bus_blocked(struct brcmf_pub *drvr, bool flow_blocked);
void brcmf_fws_rxreorder(struct brcmf_if *ifp, struct sk_buff *skb);
#endif /* FWSIGNAL_H_ */
```
|
Seker (; also spelled Sokar, and in Greek, Sokaris or Socharis) is a hawk or falcon god of the Memphite necropolis in the Ancient Egyptian religion, who was known as a patron of the living, as well as a god of the dead. He is also in some accounts a solar deity as for The Temple of Seker in Memphis.
Name
Although the meaning of his name remains uncertain, the Egyptians in the Pyramid Texts linked his name to the anguished cry of Osiris to Isis 'Sy-k-ri' ('hurry to me'), or possibly skr, meaning "cleaning the mouth". In the underworld, Seker is strongly linked with two other gods, Ptah the Creator god and chief god of Memphis, and Osiris the god of the dead. In later periods, this connection was expressed as the triple god Ptah-Seker-Osiris.
The Faiyumic Coptic form ⲥⲓⲭⲟⲗ is possibly preserved in a personal name ⲥⲉⲛⲥⲓⲭⲟⲗ, "daughter of Sokar".
Appearance
Seker was usually depicted as a mummified hawk and sometimes as a mound from which the head of a hawk appears. Here he is called 'he who is on his sand'. Sometimes he is shown on his hennu barque which was an elaborate sledge for negotiating the sandy necropolis. One of his titles was 'He of Restau' which means the place of 'openings' or tomb entrances. Like many other gods, he was often depicted with a Was-scepter.
In the New Kingdom Book of the Underworld, the Amduat, he is shown standing on the back of a serpent between two spread wings; as an expression of freedom this suggests a connection with resurrection or perhaps a satisfactory transit of the underworld. Despite this, the region of the underworld associated with Seker was seen as difficult, sandy terrain called the Imhet (also called Amhet, Ammahet, or Ammehet; meaning 'filled up').
Roles and cults
Seker, possibly through his association with Ptah, has a connection with artisans. In the Book of the Dead, he is said to fashion silver bowls and at Tanis a silver coffin of Sheshonq II has been discovered decorated with the iconography of Seker.
Seker's cult centre was in Memphis, and festivals in his honor were held there on the 26th day of the fourth month of the akhet (spring) season. While these festivals took place, devotees would hoe and till the ground, and drive cattle, which suggests that Seker could have had agricultural aspects about him.
Seker is mentioned in The Journey of Ra: the myth used to explain what happens during the night when Ra travels through the Underworld. According to the myth, Seker rules the Fifth Kingdom of Night, which is called "Hidden", and is tasked with punishing the souls of evildoers by throwing them into a boiling lake.
As part of the festivals in akhet, his followers wore strings of onions around their necks, showing the Underworld aspect of him. Onions were used in embalming people - sometimes the skin, sometimes the entire onion. When just the skin was used, it would be placed on the eyes and inside the ears to mask the smell.
Also, the god was depicted as assisting in various tasks such as digging ditches and canals. From the New Kingdom a similar festival was held in Thebes, which rivaled the great Opet Festival.
Other events during the festival including floating a statue of the god on a Henu barque, which was a boat with a high prow shaped like an oryx.
Popular culture
In the film The Ten Commandments (1956), the Pharaoh Rameses II invokes the same deity to bring his deceased firstborn son back to life, while wearing a dark blue robe with a silver bow.
In the show Stargate SG-1, the Goa'uld villain Sokar is named after Seker. Sokar appears as a powerful and sadistic Goa'uld who chose the role of the Devil rather than a god like the rest of his species. He is killed when the moon he uses as his own personal version of Hell is blown up, destroying Sokar's ship in orbit and Sokar himself.
American technical death metal band Nile wrote the title track of their album “Annihilation of the Wicked” about the domain, occupation, and appearance of Seker. Curiously, the lyrics seem to describe Seker in the form of Seker-Osiris, not Ptah-Seker-Osiris, deliberately excluding the aspects of Ptah. The lyrics call him "ancient and dead", a trait held by Osiris, but also describe him as being “shunned by Ra,” which would place the Seker they describe in the context of Heliopolis rather than Memphis.
The fantasy role playing game "Advanced Dungeons and Dragons" includes Seker in its 1st edition, "Deities and Demigods", and the "Legends and Lore" rulebooks. In this setting, Seker is described as the Egyptian lesser god of light and, among other details, he casts rays of light from his hands which destroy all undead. His Alignment is given as Neutral Good, and it is noted he protects Egyptian souls of the same Alignment after their death. No specific mention is made of the later triple persona, though his symbol is given as a hawk-headed mummy holding an ankh, which does at least indirectly suggest the connection.
Gallery
See also
Sokar (Stargate)
References
Bibliography
Graindorge, Catherine (1994). Le Dieu Sokar a Thebes Au Nouvel Empire (in French). Otto Harrassowitz Verlag. .
Mikhail, Louis B. (1984). "The Festival of Sokar: An Episode of the Osirian Khoiak Festival". Göttinger Miszellen 82.
External links
Arts gods
Crafts gods
Egyptian death gods
Smithing gods
Underworld gods
Falcon deities
Epithets of Ptah
|
The Man Who Broke Britain is a 2004 BBC Television drama about a financial collapse triggered by a devastating terrorist strike.
Plot
A devastating terrorist strike wipes out much of Saudi Arabia's oil production; the same day a trader of Saudi origin disappears from the fictional UK investment bank Sun First Credit (SFCB). Managers soon discover the missing trader, Samir Badr, has built up crippling debts, multiplied a hundredfold by the attacks in Saudi. SFCB, once the toast of the city, is suddenly heading for bankruptcy, taking a whole raft of other banks with it. The resulting market crash and banking crisis will push Britain and the US into a 21st Century recession: pension funds are slashed, unemployment soars and the housing market collapses. Following the discovery that Badr has committed suicide, a new Al-Qa'eda tape surfaces, in which Osama Bin Laden appears to claim responsibility for the financial turmoil. Suspicion grows that Badr was an Islamic extremist who deliberately sabotaged the bank. As the authorities and the media launch a massive investigation into the apparent Al-Qaeda assault on the pillars of the Western Economy, an alternative explanation emerges. Could greed and incompetence be the real cause of the collapse of Britain's economy?
External links
Production website at Wall to Wall Media
The Man Who Broke Britain at British Film Institute
British docufiction films
BBC television docudramas
Films set in the United Kingdom
2004 television films
2004 films
2004 in British television
British television films
Films about terrorism in Asia
Films about terrorism in Europe
2000s British films
|
```java
package com.fishercoder.solutions.firstthousand;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;
public class _433 {
public static class Solution1 {
/**
* My completely original solution, BFS.
*/
public int minMutation(String startGene, String endGene, String[] bank) {
boolean found = false;
for (String b : bank) {
if (b.equals(endGene)) {
found = true;
}
}
if (!found) {
return -1;
}
Queue<String> q = new LinkedList<>();
q.offer(startGene);
int mutations = 0;
Set<String> used = new HashSet<>();
used.add(startGene);
while (!q.isEmpty()) {
int size = q.size();
for (int i = 0; i < size; i++) {
String curr = q.poll();
if (curr.equals(endGene)) {
return mutations;
}
for (String candidate : bank) {
if (oneDiff(curr, candidate) && used.add(candidate)) {
q.offer(candidate);
}
}
}
mutations++;
}
return -1;
}
private boolean oneDiff(String word1, String word2) {
int diffChars = 0;
for (int i = 0; i < word1.length(); i++) {
if (word1.charAt(i) != word2.charAt(i)) {
diffChars++;
}
}
return diffChars == 1;
}
}
}
```
|
Asen Nikolov (; 12 September 1891 - 1946) was a Bulgarian Lieutenant-General who fought in World War II.
Biography
He was born on 12 September 1891 in the town of Yambol. He graduated from the Military School in Sofia in 1912. From 1923 he served in the Varna coastal fortress. In 1934 he became head of the Artillery School in Sofia. From 1936 he was chief of the Artillery Department of the Second Military Inspection District and chief of the Air Defense of the Artillery Inspection.
In 1938 he was appointed commander of the 2nd Thracian Infantry Division.
From 1941 he was commander of the Bulgarian 1st Occupation Corps which collaborated with the German Army in the Axis occupation of Serbia. When Bulgaria switched sides in the second World War, he was taken prisoner by the Germans on 4 September 1944. In October 1944, he refused to join the creation of a Bulgarian military unit to fight on the German side. In December he also refused to enter in the Anti-Communist government in exile of Alexander Tsankov. In the period December 1944 - May 1945 he was a prisoner of war in the Oflag-8 camp in Germany.
On 15 March 1945 he was sentenced in absentia to death by the Fourth Supreme Chamber of the People's Court of Bulgaria, but the Supreme Court of Cassation overturned the sentence because it had been proven he was a prisoner of war. After his return to Bulgaria, he was arrested and executed anyhow in 1946.
Sources
generals.dk
the article in the Bulgarian Wikipedia, Асен Николов (генерал-лейтенант).''
boinaslava
1891 births
1946 deaths
Bulgarian military personnel of World War II
Bulgarian generals
People's Court (Bulgaria)
Executed Bulgarian collaborators with Nazi Germany
|
```xml
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="path_to_url"
android:shape="rectangle">
<corners android:radius="20dp"/>
<solid android:color="@android:color/holo_blue_bright"/>
</shape>
```
|
```go
//
// Run 'make generate-mocks' to regenerate.
// Code generated by mockery. DO NOT EDIT.
package mocks
import mock "github.com/stretchr/testify/mock"
// Message is an autogenerated mock type for the Message type
type Message struct {
mock.Mock
}
// Key provides a mock function with given fields:
func (_m *Message) Key() []byte {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for Key")
}
var r0 []byte
if rf, ok := ret.Get(0).(func() []byte); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]byte)
}
}
return r0
}
// Offset provides a mock function with given fields:
func (_m *Message) Offset() int64 {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for Offset")
}
var r0 int64
if rf, ok := ret.Get(0).(func() int64); ok {
r0 = rf()
} else {
r0 = ret.Get(0).(int64)
}
return r0
}
// Partition provides a mock function with given fields:
func (_m *Message) Partition() int32 {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for Partition")
}
var r0 int32
if rf, ok := ret.Get(0).(func() int32); ok {
r0 = rf()
} else {
r0 = ret.Get(0).(int32)
}
return r0
}
// Topic provides a mock function with given fields:
func (_m *Message) Topic() string {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for Topic")
}
var r0 string
if rf, ok := ret.Get(0).(func() string); ok {
r0 = rf()
} else {
r0 = ret.Get(0).(string)
}
return r0
}
// Value provides a mock function with given fields:
func (_m *Message) Value() []byte {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for Value")
}
var r0 []byte
if rf, ok := ret.Get(0).(func() []byte); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]byte)
}
}
return r0
}
// NewMessage creates a new instance of Message. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMessage(t interface {
mock.TestingT
Cleanup(func())
}) *Message {
mock := &Message{}
mock.Mock.Test(t)
t.Cleanup(func() { mock.AssertExpectations(t) })
return mock
}
```
|
Shahed 121 is an Iranian unmanned aerial vehicle (UAV), part of the drone family that includes the Shahed 125 and Shahed 129. Shahed translates in the Arabic and Persian languages to witness.
It was noticed in 2016 when it flew over the USS Harry S. Truman, a nuclear-power aircraft carrier, in international airspace. The US Navy regarded this as a security breach which had not happened since 2014. The incident occurred after a nuclear deal that Iran signed with world powers, including the US. A US Navy Seahawk helicopter filmed the incident. The flight of Shahed 121 was considered by Iranian authorities to be safe as its wings were all "clean", implying that the drone did not carry weapons and was not dangerous to ships but the high command of the US Navy described it as "abnormal" and "unprofessional".
References
149
Military equipment of Iran
Unmanned aerial vehicles of Iran
Aircraft manufactured in Iran
Iranian military aircraft
|
Napoleon at Waterloo is a board wargame published by Simulations Publications Inc. (SPI) in 1971 that simulates the Battle of Waterloo. The game, which features simple rules, was designed as an introduction to board wargaming, and was given as a free gift with each subscription to SPI's Strategy & Tactics magazine.
Description
Napoleon at Waterloo is a two-player grand tactical board wargame in which one player takes the role of Napoleon controlling the French forces, and the other player takes the role of the Duke of Wellington controlling the Anglo-Allied forces. The game comes with a single scenario based on the historical battle.
Components
The free game sent to new subscribers of Strategy & Tactics consisted of:
17" x 23" paper hex grid map
80 die-cut counters
map-folded rulesheet
SPI Letter of Introduction and Examples of Play
For sale in stores, SPI packaged the game in a "flatpack" box with cover art and an integral tray.
Gameplay
The game uses a simple "I Go, You Go" system of alternating player turns:
The French player moves all units desired, and engages in combat.
The second player then has the same opportunity.
This completes one game turn, which represents 1 hour of game time. In addition:
Stacking of units is prohibited.
There are no supply rules.
Zones of control are both "rigid" and "sticky": a unit moving adjacent to an enemy unit must stop there. Combat is mandatory, and units thus engaged cannot move away from each other except as a result of combat.
Victory conditions
The French win by demoralizing their enemies and moving at least 7 units off the north side of the map. The Allies win by inflicting 40 points of damage on the French without taking 40 points of damage themselves.
Publication history
In 1969, game designer Jim Dunnigan formed Poultron Press to take over the failing wargaming magazine Strategy & Tactics. The small company also released a series of cheaply made "test" board wargames to see if there was a market for them. The results were promising, and Dunnigan changed the name of the company to Simulations Publications Inc. (SPI) and began to market professionally printed games. One of the first, designed by Dunnigan and published in 1971, was Napoleon at Waterloo, a small and simple game with a two-tone brown and tan map designed by Redmond A. Simonsen. It was meant to introduce new players to the wargame hobby. In addition to being sold in stores, a free copy of Napoleon at Waterloo was mailed to new subscribers of Strategy & Tactics. In addition, non-subscribers could get a free copy of the game simply by writing to SPI.
The game proved popular, and SPI immediately released the Napoleon at Waterloo Advanced Game Expansion Kit, which included an expanded set of counters, extra rules and more scenarios.
The game was popular because of its simple game mechanics, and these were subsequently used in many smaller SPI games including The Battle of Borodino (1972), Austerlitz (1973), Blue & Gray (1975), Napoleon at War (1975), Blue and Gray II (1975), Sixth Fleet (1975), Battle for Germany (1975), Napoleon's Last Battles (1976), and Road to Richmond (1977).
In 1979, SPI re-released Napoleon at Waterloo, now subtitled ""SPI Introduction to Wargaming", with an updated four-color map. The game also included the expanded rules set, counters and scenarios from the Advanced Game Expansion Kit.
After the demise of SPI, Hobby Japan obtained the rights to the game and published a Japanese language edition in 1985. In the 21st century, Decision Games acquired the rights and published a revised second edition in 2014.
Reception
In Issue 2 of the UK magazine Games & Puzzles, (July 1972), game designer Don Turnbull called it "A fine introductory game [...] Perhaps the best game for beginners — and cheap too!" Several issues later, Turnbull added, "this is perhaps the best 'simple' game of all, with 'clean' play mechanics, a small number of units, straightforward rules and interesting play." In the same issue, Turnbull also commented on the more complex Expansion Kit, saying, "Curiously enough, many experienced players prefer the simpler version — for 'cleanliness' of mechanics sake."
In a 1976 poll conducted by SPI to determine the most popular board wargames in North America, Napoleon at Waterloo was rated 136th out of 202 games.
In Issue 3 of the UK wargaming magazine Phoenix, Rob Gibson accused the game of "lack of realism (does not play like the real battle)." Gibson made four suggestions for rule changes that he felt would improve the game's historicity.
In the 1977 book The Comprehensive Guide to Board Wargaming, Nicholas Palmer called the game an "Excellent introductory game [...] exciting, easy to learn, and over in an hour (hence a favourite at one-day conventions.)" However, due to its simplicity and its age, Palmer thought that "experienced players will not find it very challenging, and the game techniques are no longer all that good an introduction to recent designs." Palmer also reviewed the Expansion Kit, and called it "More to the taste of the hard-core [gamers], but still at the easy end of the scale." He concluded that it was a "Good second game for those who started with the basic version."
Games magazine included Napoleon at War in their "Top 100 Games of 1980", saying, "An ideal introduction to wargaming, Napoleon at Waterloo is one of the most easily learned and played examples of its genre."
In Issue 50 of The Space Gamer, W.G. Armintrout noted that the game was specifically designed for new hobbyists, saying, "The rules carefully expose new gamers to such wonders as zones of control, artillery bombardment, and odds-ratio combat." He concluded, "The game, although not quite filled with heart-stopping excitement, is an excellent introduction to the hobby."
In Issue 53 of Moves, Ian Chadwick thought there were balance issues, commenting that "The French have a tough time of winning since the onus is on them to batter the Allies before the Prussians can arrive, and also escape off the board with enough units." Although he thought the then nine-year-old game was still a good introduction to the hobby, he questioned whether more experienced players would find it a challenge, saying "By today's standards, the game simply is not adequate for the average or better gamer, but it is excellent for introducing the young neophyte into the art and science of wargaming." He concluded by giving the game grades of "B" for playability, "C" for historical accuracy, and "B" for component quality.
In Issue 24 of Fire & Movement, Bill Haggart thought this game was "nearly flawless. She is quick, enjoyable, easily learned, and has the allure of [Avalon Hill]'s Waterloo. More importantly, her rules are concise, comprehensive, and wonder of wonders, consistent." However, Haggart did note, "As a simulation, Napoleon at Waterloo is not as successful," citing issues with artillery fire, command control, and overuse of the best units on the board.
In The Guide to Simulations/Games for Education and Training, Martin Campion commented "Neither the advanced game or the standard game are particularly realistic, but the standard game is useful as an introductory game."
In the 1980 book The Complete Book of Wargames, game designer Jon Freeman commented, "Despite its simplicity, a good deal of tension is generated during play." Freeman concluded by giving this game an Overall Evaluation of "Good to Very Good."
Other reviews and commentary
The Wargamer Vol.1 #4
International Wargamer Vol.5 #2
Panzerfaust #63
Jagdpanther #9
Battle Flag Vol.1 #26
References
Board wargames set in Modern history
Jim Dunnigan games
Napoleonic Wars games
Simulations Publications games
Wargames introduced in 1971
|
Arlen Darryl Ness (July 12, 1939 – March 22, 2019) was an American motorcycle designer and entrepreneur best known for his custom motorcycles. Ness received acclaim for his designs, most of which are noted for their unique body style and paintwork.
Early life
Ness was born in Moorhead, Minnesota, on July 12, 1939, to Elaine and Ervin Ness, and moved to San Lorenzo, California, when he was in the sixth grade.
Prior to his career as a motorcycle builder, Ness worked as a pin setter at the local bowling alley, and later as a post office worker and furniture mover. He competed in semi-professional bowling leagues, the earnings of which he used to buy his first motorcycle, a 1947 Harley-Davidson Knucklehead that he later customized.
Ness was married to his wife Beverly for 59 years until his death.
Career
His first customized bikes were made in the garage of his home in San Leandro, California, but by the early 1970s he had moved to a storefront on East 14th Street.
Ness was recognized for his painting style and for developing a line of custom motorcycle parts. His popularity grew as he built new custom bikes and then had those displayed on the bike show circuit and featured in motorcycle magazines.
After more than three decades of custom bike building, his business, Arlen Ness Motorcycles, moved to a Dublin, California, facility that includes a museum with more than 40 of his custom motorcycles, including his Untouchable, the twin motor Two Bad, the antique inspired Ness-Tique, Blower Bike, the Italian sports car inspired Ferrari Bike, the '57 Chevy inspired Ness-Stalgia, the Bugatti-like Smooth-Ness, the Discovery Channel's Biker Build-Off bike Top Banana and his jet-powered Mach Ness. The company is also an authorized dealership for Victory Motorcycles and for Indian Motorcycles.
The Mach Ness is a motorcycle that Ness built in 2005, inspired by Jay Leno's turbine-powered bike, that uses a jet-powered helicopter engine as its power plant. The design, concept, paint and graphics were created by Carl Brouhard and the hand-made aluminum body work was by Bob Monroe.
Ness received recognition and awards including Builder of the Year, induction into the Motorcycle Hall of Fame and Lifetime Achievement Awards. His son, Cory Ness, worked with Ness for more than 30 years, and now runs the day-to-day business operations at Arlen Ness, Inc. Cory has himself been recognized as a top custom bike builder and even defeated his father in a 2004 episode of Biker Build-Off. Carrying on the family tradition to a third generation, Cory's son, Zach Ness, built several high end custom bikes before finishing high school in 2006.
Ness received a patent for the Big Shot, a method of altering the motorcycle's fuel injection system, and thereby enhancing its performance.
Ness died on March 22, 2019, at the age of 79.
Gallery
References
Further reading
External links
1939 births
2019 deaths
Motorcycle builders
American motorcycle designers
People from San Lorenzo, California
Dublin, California
People from Moorhead, Minnesota
Vehicle modification people
|
```smalltalk
using Avalonia;
using Avalonia.Controls;
using Avalonia.Threading;
using Avalonia.Xaml.Interactivity;
namespace WalletWasabi.Fluent.Behaviors;
/// <summary>
/// Focuses the associated or target control when executed.
/// </summary>
public class FocusControlActionCustom : AvaloniaObject, IAction
{
/// <summary>
/// Identifies the <seealso cref="TargetControl"/> Avalonia property.
/// </summary>
public static readonly StyledProperty<Control?> TargetControlProperty =
AvaloniaProperty.Register<FocusControlActionCustom, Control?>(nameof(TargetControl));
/// <summary>
/// Gets or sets the target control. This is an Avalonia property.
/// </summary>
[ResolveByName]
public Control? TargetControl
{
get => GetValue(TargetControlProperty);
set => SetValue(TargetControlProperty, value);
}
/// <summary>
/// Executes the action.
/// </summary>
/// <param name="sender">The <see cref="object"/> that is passed to the action by the behavior. Generally this is <seealso cref="IBehavior.AssociatedObject"/> or a target object.</param>
/// <param name="parameter">The value of this parameter is determined by the caller.</param>
/// <returns>Returns null after executed.</returns>
public virtual object? Execute(object? sender, object? parameter)
{
var control = TargetControl ?? sender as Control;
Dispatcher.UIThread.Post(() => control?.Focus());
return null;
}
}
```
|
Howard City is a village in Montcalm County in the U.S. state of Michigan. The population was 1,808 at the 2010 census. The village is within Reynolds Township.
History
Benjamin Ensley owned the land on which he, E. W. Muenscher, and Mr. Shaw began the settlement that Muenscher platted in 1868. It was named for William A. Howard, a Detroit railroad attorney. The Detroit, Grand Rapids and Western Railroad depot opened in 1869. A post office was established on January 12, 1870, with John B. Spencer as the first postmaster. It incorporated as a village in 1873. The post office name was shortened to "Howard" on February 2, 1895, but restored to Howard City on January 19, 1899.
Main street was initially constructed on Ensley Street, which was named after early settler Benjamin Ensley. In 1883, however, many of the wooden buildings on Ensley street burned down. Main Street was then shifted over to Edgerton Street, where it still stands today. The Hudson Knife factory and The Skinner and Steenman sideboard factory were two of the earliest businesses. Later, Hudson Knife Co. went through changes and became the Joslin and eventually Olsen Knife Company, which had the somewhat famous jingle, "Fatty Fatty run for your life, here comes Skinny with an Olsen Knife." Howard City schools were combined with Sand Lake schools to the south in 1962, and renamed Tri County, because students from Kent, Montcalm, and Newaygo counties all attended. The school still runs under the same moniker today.
Schools
Tri County Area Schools is the main school district in Howard City. Schools include Tri County High School, Tri County Middle School, MacNaughten Elementary, Sand Lake Elementary and Edgerton Upper Elementary. The School mascot is the Viking. Sports include football, basketball, softball, baseball, wrestling, sideline cheer, competitive cheer, golf, track and field, cross country, bowling, poms and soccer. In 2009, the varsity softball team took a District title, but fell short at regionals to Petosky.
Neighboring schools include Newaygo, Grant, Morley-Stanwood, Lakeview and Cedar Springs.
The district was a consolidation of the Sand Lake and Howard City school boards. It came into existence on April 3, 1962, the day members of those communities voted in favor of consolidating their schools. The consolidated schools began operation in fall 1962. Prior to the consolidation, Howard City High School served the community. Impetus for consolidation occurred when the State of Michigan adopted new standards for education which required school systems to spend additional funds. A former member of the school board of Sand Lake, Charles Northup, stated, "Howard City was almost in the same predicament as us. We figured we would have a good school system coming together." Sand Lake was a community which sought consolidation due to the financial strain from meeting the new requirements.
Geography
According to the United States Census Bureau, the village has a total area of , of which, of it is land and is water.
The Howard City post office, with ZIP code 49329, also serves much of southern Reynolds Township, as well as a large part of Winfield Township to the east, a small area of Maple Valley Township to the southeast, portions of Pierson Township to the south. It also serves parts of Croton Township to the west and Ensley Township to the southwest in Newaygo County.
Demographics
2010 census
As of the census of 2010, there were 1,808 people, 685 households, and 464 families residing in the village. The population density was . There were 743 housing units at an average density of . The racial makeup of the village was 96.3% White, 0.6% African American, 0.6% Native American, 0.2% Asian, 0.8% from other races, and 1.5% from two or more races. Hispanic or Latino of any race were 2.4% of the population.
There were 685 households, of which 39.7% had children under the age of 18 living with them, 45.1% were married couples living together, 17.4% had a female householder with no husband present, 5.3% had a male householder with no wife present, and 32.3% were non-families. 26.4% of all households were made up of individuals, and 10.9% had someone living alone who was 65 years of age or older. The average household size was 2.63 and the average family size was 3.13.
The median age in the village was 33.6 years. 29.4% of residents were under the age of 18; 9.1% were between the ages of 18 and 24; 26.9% were from 25 to 44; 21.8% were from 45 to 64; and 12.9% were 65 years of age or older. The gender makeup of the village was 46.6% male and 53.4% female.
2000 census
As of the census of 2000, there were 1,585 people, 576 households, and 410 families residing in the village. The population density was . There were 626 housing units at an average density of . The racial makeup of the village was 95.90% White, 0.19% African American, 0.57% Native American, 0.13% Asian, 0.95% from other races, and 2.27% from two or more races. Hispanic or Latino of any race were 2.59% of the population.
There were 576 households, out of which 38.7% had children under the age of 18 living with them, 52.4% were married couples living together, 14.1% had a female householder with no husband present, and 28.8% were non-families. 25.2% of all households were made up of individuals, and 13.9% had someone living alone who was 65 years of age or older. The average household size was 2.75 and the average family size was 3.22.
In the village, the population was spread out, with 32.3% under the age of 18, 8.9% from 18 to 24, 27.9% from 25 to 44, 17.7% from 45 to 64, and 13.2% who were 65 years of age or older. The median age was 32 years. For every 100 females, there were 84.9 males. For every 100 females age 18 and over, there were 83.4 males.
The median income for a household in the village was $34,556, and the median income for a family was $41,250. Males had a median income of $32,241 versus $22,917 for females. The per capita income for the village was $14,076. About 5.7% of families and 10.4% of the population were below the poverty line, including 13.4% of those under age 18 and 13.1% of those age 65 or over.
Transportation
Indian Trails provides daily intercity bus service between Grand Rapids, Michigan and Petoskey, Michigan.
References
External links
Howard City website
Villages in Montcalm County, Michigan
Villages in Michigan
|
```makefile
################################################################################
#
# dbus-triggerd
#
################################################################################
DBUS_TRIGGERD_VERSION = ba3dbec805cb707c94c54de21666bf18b79bcc09
DBUS_TRIGGERD_SITE = git://rg42.org/dbustriggerd.git
DBUS_TRIGGERD_LICENSE = GPL-2.0+
DBUS_TRIGGERD_LICENSE_FILES = dbus-triggerd.c
DBUS_TRIGGERD_DEPENDENCIES = host-pkgconf dbus
define DBUS_TRIGGERD_BUILD_CMDS
$(TARGET_MAKE_ENV) $(TARGET_CONFIGURE_OPTS) $(MAKE) -C $(@D) all
endef
define DBUS_TRIGGERD_INSTALL_TARGET_CMDS
$(TARGET_MAKE_ENV) $(MAKE) DESTDIR="$(TARGET_DIR)" -C $(@D) install
endef
$(eval $(generic-package))
```
|
```xml
import type { DOMConversionOutput, LexicalNode } from 'lexical'
import { BubbleNode } from './BubbleNode'
export function convertToBubbleElement(domNode: HTMLDivElement): DOMConversionOutput | null {
const itemUuid = domNode.getAttribute('data-lexical-item-uuid')
if (itemUuid) {
const node = $createBubbleNode(itemUuid)
return { node }
}
return null
}
export function $createBubbleNode(itemUuid: string): BubbleNode {
return new BubbleNode(itemUuid)
}
export function $isBubbleNode(node: BubbleNode | LexicalNode | null | undefined): node is BubbleNode {
return node instanceof BubbleNode
}
```
|
The Serra do Mar (, Portuguese for Sea's Ridge or Sea Ridge) is a 1,500 km long system of mountain ranges and escarpments in Southeastern Brazil.
Geography
The Serra do Mar runs parallel to the Atlantic Ocean coast from the state of Espírito Santo to southern Santa Catarina, although some literature includes the Serra Geral in the Serra do Mar, in which case the range would extend to northeastern Rio Grande do Sul.
The main escarpment forms the boundary between the sea-level littoral and the inland plateau (planalto), which has a mean altitude of . This escarpment is part of the Great Escarpment that runs along much of the eastern coast of Brazil south from the city of Salvador, Bahia.
Mountain ranges
The mountain ranges are discontinuous in several places and are given individual names such as Serra de Bocaina, Serra de Paranapiacaba, Serra Negra, Serra dos Órgãos, Serra do Indaiá, etc. The range also extends to some large islands near the coastline, such as Ilhabela and Ilha Anchieta. With an altitude of , Pico da Caledônia in Nova Friburgo is among the highest points in Serra do Mar.
Geologically, the range belongs to the massive crystalline rock platform that forms Eastern South America, and tectonically it is very stable. Most of the elevations of Serra do Mar were formed about 60 million years ago.
Natural history
At the time of the European discovery of Brazil (1500), the Serra do Mar supported a rich and highly diversified ecosystem, composed mainly of lush tropical rain forest, called Atlantic Forest (Mata Atlântica). Due to urbanization and deforestation, however, most of the forest cover has been destroyed and what cover remains is almost exclusively on the steep escarpments facing the sea.
A chain of national and state parks, ecological stations and biological reserves now protect the Mata Atlântica and its biological heritage, but acid rain, pollution, poachers, clandestine loggers, forest fires and encroachment by urban areas and farms are still causing active destruction, particularly in the areas around cities. Several large metropolises, such as Vale do Itajaí, Curitiba, São Paulo and Rio de Janeiro, are near the Serra do Mar.
Reforestation and recuperation of biological diversity are notoriously difficult to bring about in destroyed rain forest habitats.
See also
Ecoregions of the Atlantic Forest biome
List of plants of Atlantic Forest vegetation of Brazil
References
Mar, Serra do
Atlantic Forest
Escarpments
Landforms of Espírito Santo
Landforms of Rio de Janeiro (state)
Landforms of São Paulo (state)
Landforms of Santa Catarina (state)
World Heritage Sites in Brazil
|
```c
/*
* GRUB Utilities -- Utilities for GRUB Legacy, GRUB2 and GRUB for DOS
*
* This program is free software: you can redistribute it and/or modify
* (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
*
* along with this program. If not, see <path_to_url
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <assert.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <time.h>
#include "xdio.h"
#include "keytab.h"
#include "version.h"
#include "fbinst.h"
#include "fb_mbr_rel.h"
#include "fb_mbr_dbg.h"
#ifdef WIN32
#include <windows.h>
#endif
#define BUILD_NUMBER 1
char *progname = "fbinst";
int verbosity = 0;
char *fb_mbr_data = fb_mbr_rel;
#define DEF_FAT32_SIZE 512 * 2048
#define MIN_FAT16_SIZE 8400 + 1
#define DEF_BASE_SIZE 63
#define DEF_LIST_SIZE 1024
#define DEF_PRI_SIZE 63 * 256
#define GLOB_BUF_SIZE 64
#define uchar unsigned char
#define uchar2 unsigned short
#define uchar4 unsigned long
#ifdef __GNUC__
#define PACK __attribute__((packed))
#else
#define PACK
#pragma pack(1)
#endif
struct fb_mbr
{
uchar jmp_code;
uchar jmp_ofs;
uchar boot_code[0x1a9];
uchar max_sec; /* 0x1ab */
uchar2 lba; /* 0x1ac */
uchar spt; /* 0x1ae */
uchar heads; /* 0x1af */
uchar2 boot_base; /* 0x1b0 */
uchar2 boot_size; /* 0x1b2 */
uchar4 fb_magic; /* 0x1b4 */
uchar mbr_table[0x46]; /* 0x1b8 */
uchar2 end_magic; /* 0x1fe */
} PACK;
struct fb_data
{
uchar2 menu_ofs; /* 0x200 */
uchar2 flags; /* 0x202 */
uchar ver_major; /* 0x204 */
uchar ver_minor; /* 0x205 */
uchar4 pri_size; /* 0x206 */
uchar4 ext_size; /* 0x20a */
} PACK;
struct fb_ar_data
{
uchar4 ar_magic; /* 0x200 */
uchar ver_major; /* 0x204 */
uchar ver_minor; /* 0x205 */
uchar4 pri_size; /* 0x206 */
uchar4 ext_size; /* 0x20a */
uchar4 boot_size; /* 0x20e */
} PACK;
struct fat_bs16
{
uchar jb[3]; /* Jump boot */
char on[8]; /* Oem name */
uchar2 bps; /* Bytes per sector */
uchar spc; /* Sectors per cluster */
uchar2 nrs; /* Number of reserved sector */
uchar nf; /* Number of FATs */
uchar2 nrd; /* Number of root directory entries */
uchar2 ts16; /* 16-bit total sector number */
uchar md; /* Media */
uchar2 fz16; /* 16-Bit FAT size */
uchar2 spt; /* Sectors per track */
uchar2 nh; /* Number of heads */
uchar4 nhs; /* Number of hidden sectors */
uchar4 ts32; /* 32-Bit total sectors */
uchar dn; /* Drive number */
uchar r1; /* Reserved field 1 */
uchar ebs; /* Extended boot sigature (0x29) */
uchar4 vn; /* Volume serial number */
char vl[11]; /* Volume label */
char fs[8]; /* File system */
char bc[448]; /* Boot code */
uchar2 bss; /* Boot sector sigature (0xAA55) */
} PACK;
struct fat_bs32
{
uchar jb[3]; /* Jump boot */
char on[8]; /* Oem name */
uchar2 bps; /* Bytes per sector */
uchar spc; /* Sectors per cluster */
uchar2 nrs; /* Number of reserved sector */
uchar nf; /* Number of FATs */
uchar2 nrd; /* Number of root directory entries */
uchar2 ts16; /* 16-bit total sector number */
uchar md; /* Media */
uchar2 fz16; /* 16-Bit FAT size */
uchar2 spt; /* Sectors per track */
uchar2 nh; /* Number of heads */
uchar4 nhs; /* Number of hidden sectors */
uchar4 ts32; /* 32-Bit total sectors */
uchar4 fz32; /* 32-Bit FAT size */
uchar2 ef; /* Extended flags */
uchar2 fsv; /* File system version */
uchar4 rc; /* Root cluster */
uchar2 fsi; /* Sector number of FSINFO structure (1) */
uchar2 bbs; /* Backup boot sector (6) */
uchar r1[12]; /* Reserved field 1 */
uchar dn; /* Drive number */
uchar r2; /* Reserved field 2 */
uchar ebs; /* Extended boot sigature (0x29) */
uchar4 vn; /* Volume serial number */
char vl[11]; /* Volume label */
char fs[8]; /* File system */
uchar bc[420]; /* Boot code */
uchar2 bss; /* Boot sector sigature (0xAA55) */
} PACK;
struct fbm_file
{
uchar size;
uchar type;
uchar4 data_start;
uchar4 data_size;
time_t data_time;
uchar flag;
char name[0];
} PACK;
struct fbm_text
{
uchar size;
uchar type;
char title[0];
} PACK;
struct fbm_menu
{
uchar size;
uchar type;
uchar2 key;
uchar sys_type;
char name[0];
} PACK;
struct fbm_timeout
{
uchar size;
uchar type;
uchar timeout;
} PACK;
#ifdef __GNUC__
#undef PACK
#else
#pragma pack()
#endif
void
info (char *fmt, ...)
{
if (verbosity > 0)
{
va_list ap;
fprintf (stderr, "%s: info: ", progname);
va_start (ap, fmt);
vfprintf (stderr, fmt, ap);
va_end (ap);
fputc ('\n', stderr);
fflush (stderr);
}
}
void
quit (char *fmt, ...)
{
va_list ap;
fprintf (stderr, "%s: error: ", progname);
va_start (ap, fmt);
vfprintf (stderr, fmt, ap);
va_end (ap);
fputc ('\n', stderr);
exit (1);
}
void *
xmalloc (int size)
{
void *p;
p = malloc (size);
if (! p)
quit ("not enough memory");
return p;
}
void
help (void)
{
printf ("Usage:\n"
"\tfbinst [OPTIONS] DEVICE_OR_FILE COMMANDS [PARAMETERS]\n\n"
"Global Options:\n"
" --help,-h\t\tDisplay this message and exit\n"
" --version,-V\t\tPrint version information and exit\n"
" --list,-l\t\tList all disks in system and exit\n"
" --verbose,-v\t\tPrint verbose messages\n"
" --debug,-d\t\tUse the debug version of mbr\n\n"
"Commands:\n"
" format\t\tFormat disk\n"
" --raw,-r\t\tFormat with normal layout (not bootable)\n"
" --force,-f\t\tForce the creation of data partition\n"
" --zip,-z\t\tFormat as USB-ZIP\n"
" --fat16\t\tFormat data partition as FAT16\n"
" --fat32\t\tFormat data partition as FAT32\n"
" --align,-a\t\tAlign to cluster boundary\n"
" --unit-size,-u NUM\tUnit size for FAT16/FAT32 in sectors\n"
" --base,-b NUM\tSet base boot sector\n"
" --size,-s NUM\tSet size of data partition\n"
" --primary,-p NUM\tSet primary data size\n"
" --extended,-e NUM\tSet extended data size\n"
" --list-size,-l NUM\tSet size of file list\n"
" --max-sectors NUM\tSet maximum number of sectors per read\n"
" --archive FILE\tInitialize fb using archive file\n"
" restore\t\tTry to restore fb mbr\n"
" update\t\tUpdate boot code\n"
" sync\t\t\tSynchronize disk information\n"
" --copy-bpb\t\tCopy bpb from the first partition\n"
" --clear-bpb\t\tClear bpb in the boot sector\n"
" info\t\t\tShow disk information\n"
" clear\t\t\tClear files\n"
" add NAME FILE\t\tAdd/update file item\n"
" --extended,-e\tStore the file in extended data area\n"
" --syslinux,-s\tPatch syslinux boot file\n"
" add-menu NAME FILE\tAdd/update menu file\n"
" --append,-a\t\tAppend to existing menu file\n"
" --string,-s\t\tThe menu items are passed as command argument\n"
" resize NAME SIZE\tResize/create file item\n"
" --extended,-e\tStore the file in extended data area\n"
" --fill,-f NUM\tSet fill character for expansion\n"
" copy OLD NEW\t\tCopy file item\n"
" move OLD NEW\t\tMove file item\n"
" export NAME FILE\tExport file item\n"
" remove NAME\t\tRemove file item\n"
" cat NAME\t\tShow the content of text file\n"
" cat-menu NAME\t\tShow the content of menu file\n"
" pack\t\t\tPack free space\n"
" check\t\t\tCheck primary data area for inconsistency\n"
" save FILE\t\tSave to archive file\n"
" --list-size,-l NUM\tSet size of file list\n"
" load FILE\t\tLoad from archive file\n");
}
void
list_devs (void)
{
int i;
char name[16];
for (i = 0; i < MAX_DISKS; i++)
{
xd_t *xd;
sprintf (name, "(hd%d)", i);
xd = xd_open (name, 1);
if (xd)
{
unsigned long size;
size = xd_size (xd);
if (size == XD_INVALID_SIZE)
printf ("%s: can\'t get size\n", name);
else
{
int s;
char c;
if (size >= (3 << 20))
{
s = (size + (1 << 20)) >> 21;
c = 'g';
}
else
{
s = (size + (1 << 10)) >> 11;
c = 'm';
}
printf ("%s: %lu (%d%c)\n", name, size, s, c);
}
xd_close (xd);
}
}
}
uchar global_buffer[512 * GLOB_BUF_SIZE];
uchar *fb_list;
uchar4 fb_pri_size;
uchar4 fb_part_ofs;
int fb_total_size;
int fb_boot_base;
int fb_boot_size;
int fb_list_size;
int fb_list_tail;
int fb_ar_mode;
int fb_ar_size;
void
read_disk (xd_t *xd, char *buf, int size)
{
if (xd_read (xd, buf, size))
quit ("xd_read fails at offset %d, size %d", xd->ofs, size);
}
void
write_disk (xd_t *xd, char *buf, int size)
{
if (xd_write (xd, buf, size))
quit ("xd_write fails at offset %d, size %d", xd->ofs, size);
}
void
seek_disk (xd_t *xd, unsigned long ofs)
{
if (xd_seek (xd, ofs))
quit ("xd_seek fails at offset %l", ofs);
}
void
zero_disk (xd_t *xd, int size)
{
while (size)
{
int n;
n = (size <= GLOB_BUF_SIZE) ? size : GLOB_BUF_SIZE;
write_disk (xd, global_buffer, n);
size -= n;
}
}
void
copy_disk (xd_t *xd, int new, int old, int size)
{
while (size)
{
int n;
n = (size <= GLOB_BUF_SIZE) ? size : GLOB_BUF_SIZE;
seek_disk (xd, old);
read_disk (xd, global_buffer, n);
if (new < fb_pri_size)
{
int i;
for (i = 0; i < n; i++)
*((uchar2 *) &global_buffer[i * 512 + 510]) = new + i;
}
seek_disk (xd, new);
write_disk (xd, global_buffer, n);
old += n;
new += n;
size -= n;
}
}
void
format_fat16 (xd_t *xd, uchar4 ds, int unit_size, int is_align)
{
char buf[512];
uchar4 table[][2]={{8400, 0}, {32680, 2}, {262144, 4},
{524288, 8}, {1048576, 16}, {2097152, 32},
{4194304, 64}, {0xFFFFFFFF,0}};
struct fat_bs16 *pbs = (struct fat_bs16 *) &buf[0];
uchar4 i, j, nf, fz, rd;
memset(buf, 0, sizeof (buf));
pbs->jb[0] = 0xEB;
pbs->jb[1] = 0x3C;
pbs->jb[2] = 0x90;
memcpy(pbs->on, "MSWIN4.1", 8);
pbs->bps = 512;
pbs->nrs = 1;
pbs->nf = 2;
pbs->nrd = (ds < MIN_FAT16_SIZE) ? 0xF0 : ((xd->ofs & 1) ? 0x200 : 0x1F0);
pbs->md = (ds < MIN_FAT16_SIZE) ? 0xF0 : 0xF8;
pbs->spt = 63;
pbs->nh = 255;
pbs->nhs = xd->ofs;
pbs->dn = 0x80;
pbs->ebs = 0x29;
pbs->vn = 0;
memcpy(pbs->vl, "NO NAME ", 11);
memcpy(pbs->fs, "FAT16 ", 8);
if (ds < MIN_FAT16_SIZE)
pbs->fs[4] = '2';
pbs->bss = 0xAA55;
if (ds < 65536)
pbs->ts16 = (uchar2) ds;
else
pbs->ts32 = ds;
if (ds == 2880)
{
pbs->spc = 1;
pbs->fz16 = 9;
pbs->spt = 18;
pbs->nh = 2;
}
else if (ds == 5760)
{
pbs->spc = 2;
pbs->fz16 = 9;
pbs->spt = 36;
pbs->nh = 2;
}
else
{
if (unit_size)
pbs->spc = unit_size;
else
{
i = 0;
while (ds > table[i][0])
i++;
if (! table[i][1])
quit ("invalid size of fat16");
pbs->spc = (uchar) table[i][1];
}
i = ds - (pbs->nrs + ((pbs->nrd * 32) + pbs->bps - 1) / pbs->bps);
j = (256 * pbs->spc) + pbs->nf;
pbs->fz16 = (uchar2)((i + (j - 1)) / j);
if (is_align)
{
uchar4 b, n;
b = xd->ofs + pbs->nrs + pbs->fz16 * 2 + (pbs->nrd * 32) / 512;
n = (b + pbs->spc - 1) / pbs->spc;
pbs->fz16 += (n * pbs->spc - b) / 2;
}
i = ds - (pbs->nrs + ((pbs->nrd * 32) + pbs->bps - 1) / pbs->bps);
i /= pbs->spc;
if (i > 65526)
quit ("unit size %d invalid for fat16", pbs->spc);
}
write_disk (xd, buf, 1);
zero_disk (xd, pbs->nrs - 1);
nf = pbs->nf;
fz = pbs->fz16;
rd = (pbs->nrd * 32 + 511) >> 9;
j = pbs->fz16 - 1;
memset(buf, 0, sizeof (buf));
if (ds < MIN_FAT16_SIZE)
*((uchar4 *) &buf[0]) = 0xFFFFF8;
else
*((uchar4 *) &buf[0]) = 0xFFFFFFF8;
for (i = 0; i < nf; i++)
{
write_disk (xd, buf, 1);
zero_disk (xd, j);
}
zero_disk (xd, rd);
}
void
format_fat32 (xd_t *xd, uchar4 ds, int unit_size, int is_align)
{
char buf[512 * 3];
uchar4 table[][2]={{66600, 0}, {532480, 1}, {16777216, 8}, {33554432, 16},
{67108864, 32}, {0xFFFFFFFF, 64}};
struct fat_bs32* pbs = (struct fat_bs32 *) &buf[0];
uchar4 i, j, nf, spc;
memset(buf, 0, sizeof (buf));
pbs->jb[0] = 0xEB;
pbs->jb[1] = 0x58;
pbs->jb[2] = 0x90;
memcpy(pbs->on, "MSWIN4.1", 8);
pbs->bps = 512;
pbs->nrs = 32 + (xd->ofs & 1);
pbs->nf = 2;
pbs->nrd = 0;
pbs->md = 0xF8;
pbs->spt = 63;
pbs->nh = 255;
pbs->nhs = xd->ofs;
pbs->rc = 2;
pbs->fsi = 1;
pbs->bbs = 6;
pbs->dn = 0x80;
pbs->ebs = 0x29;
pbs->vn = 0;
memcpy (pbs->vl, "NO NAME ", 11);
memcpy (pbs->fs, "FAT32 ", 8);
pbs->bss = 0xAA55;
*((uchar4 *) &buf[0x200]) = 0x41615252;
*((uchar4 *) &buf[0x3e4]) = 0x61417272;
*((uchar4 *) &buf[0x3e8]) = 0xFFFFFFFF;
*((uchar4 *) &buf[0x3ec]) = 0xFFFFFFFF;
*((uchar2 *) &buf[0x3fe]) = 0xAA55;
*((uchar2 *) &buf[0x5fe]) = 0xAA55;
if (unit_size)
{
pbs->spc = unit_size;
}
else
{
i = 0;
while (ds > table[i][0])
i++;
if (table[i][1] == 0)
quit ("invalid size for fat32\n");
pbs->spc = table[i][1];
}
pbs->ts16 = 0;
pbs->ts32 = ds;
i = ds - (uchar4) (pbs->nrs + ((pbs->nrd * 32) + pbs->bps - 1) / pbs->bps);
j =((256 * pbs->spc) + pbs->nf) >> 1;
pbs->fz32 = (i + (j - 1)) / j;
if (is_align)
{
uchar4 b, n;
b = xd->ofs + pbs->nrs + pbs->fz32 * 2;
n = (b + pbs->spc - 1) / pbs->spc;
pbs->fz32 += (n * pbs->spc - b) / 2;
}
i = ds - (uchar4) (pbs->nrs + ((pbs->nrd * 32) + pbs->bps - 1) / pbs->bps);
i /= pbs->spc;
if ((i <= 65526) || (i >= 4177918))
quit ("unit size %d invalid for fat32", pbs->spc);
write_disk (xd, buf, 3);
zero_disk (xd, pbs->bbs - 3);
write_disk (xd, buf, 3);
zero_disk (xd, pbs->nrs - pbs->bbs - 3);
nf = pbs->nf;
spc = pbs->spc;
j = pbs->fz32 - 1;
memset(buf, 0, sizeof (buf));
*((uchar4 *) &buf[0]) = 0xFFFFFF8;
*((uchar4 *) &buf[4]) = 0xFFFFFFF;
*((uchar4 *) &buf[8]) = 0xFFFFFFF;
for (i = 0; i < nf; i++)
{
write_disk (xd, buf, 1);
zero_disk (xd, j);
}
zero_disk (xd, spc);
}
void
lba2chs (uchar4 lba, uchar *data)
{
uchar4 tmp;
tmp = (lba / (63 * 255)) & 0x3FF;
lba = lba % (63 * 255);
data[0] = lba / 63;
data[1] = (lba % 63) + 1;
if (tmp > 255)
data[1] += (tmp >> 8) * 64;
data[2] = tmp;
}
uchar4
get_sector_size (char *s)
{
char *p;
uchar4 size;
size = strtoul (s, &p, 0);
if ((*p == 'k') || (*p == 'K'))
size <<= 1;
else if ((*p == 'm') || (*p == 'M'))
size <<= 11;
else if ((*p == 'g') || (*p == 'G'))
size <<= 21;
else if (*p)
quit ("invalid subfix %s", p);
return size;
}
void
sync_mbr (xd_t *xd, char *buf, int base, int copy_bpb)
{
int i;
seek_disk (xd, 0);
for (i = 0; i <= base; i++)
{
((struct fb_mbr *) buf)->lba = i;
if (i)
{
int j;
for (j = 0x1be; j < 0x1fe; j += 16)
{
uchar4 start, size;
if (! buf[j + 4])
continue;
(*((uchar4 *) &buf[j + 8]))--;
start = *((uchar4 *) &buf[j + 8]);
size = *((uchar4 *) &buf[j + 12]);
lba2chs (start, &buf[j + 1]);
lba2chs (start + size - 1, &buf[j + 5]);
}
if (copy_bpb)
((struct fat_bs16 *) buf)->nrs--;
}
write_disk (xd, buf, 1);
}
}
uchar4
get_part_ofs (char *buf)
{
int i;
uchar4 min;
min = 0xffffffff;
for (i = 0x1be; i < 0x1fe; i += 16)
{
uchar4 lba;
if (! buf[i + 4])
continue;
lba = *((uchar4 *) &buf[i + 8]);
if ((lba) && (lba < min))
min = lba;
}
return min;
}
uchar *
get_ar_header (int hd, int *list_size)
{
uchar *buf;
struct fb_ar_data *d1;
struct fb_data *d2;
int size;
if (read (hd, global_buffer, 512) != 512)
quit ("file read fails");
if (*((uchar4 *) global_buffer) != FB_AR_MAGIC_LONG)
quit ("invalid archive file");
d1 = (struct fb_ar_data *) global_buffer;
d2 = (struct fb_data *) (fb_mbr_data + 512);
if ((d1->ver_major != d2->ver_major) ||
(d1->ver_minor != d2->ver_minor))
quit ("version number not match");
size = d1->boot_size << 9;
buf = xmalloc (size);
size -= 512;
memcpy (buf, global_buffer, 512);
if (read (hd, buf + 512, size) != size)
quit ("file read fails");
if (list_size)
*list_size = d1->boot_size;
return buf;
}
void load_archive (xd_t *xd, int argc, char **argv);
void read_header (xd_t *xd, int allow_ar);
void write_header (xd_t *xd);
void
format_disk (xd_t *xd, int argc, char **argv)
{
struct fb_mbr *m1, *m2;
struct fb_data *data;
int i;
uchar4 max_size;
uchar4 part_size = 0;
int is_force = 0;
int is_zip = 0;
int is_raw = 0;
int is_fat32 = -1;
int is_align = 0;
int unit_size = 0;
int list_size = 0;
int base = DEF_BASE_SIZE;
int pri_size = 0;
int ext_size = 0;
int total_size = 0;
int max_sec = 0;
char *ar_file = 0;
for (i = 0; i < argc; i++)
{
if (argv[i][0] != '-')
break;
if (! strcmp (argv[i], "--size") ||
! strcmp (argv[i], "-s"))
{
if (i >= argc)
quit ("no parameter for %s", argv[i]);
i++;
part_size = get_sector_size (argv[i]);
}
else if (! strcmp (argv[i], "--primary") ||
! strcmp (argv[i], "-p"))
{
if (i >= argc)
quit ("no parameter for %s", argv[i]);
i++;
pri_size = get_sector_size (argv[i]);
if (pri_size < DEF_PRI_SIZE)
quit ("primary data size too small");
}
else if (! strcmp (argv[i], "--extended") ||
! strcmp (argv[i], "-e"))
{
if (i >= argc)
quit ("no parameter for %s", argv[i]);
i++;
ext_size = get_sector_size (argv[i]);
}
else if (! strcmp (argv[i], "--base") ||
! strcmp (argv[i], "-b"))
{
if (i >= argc)
quit ("no parameter for %s", argv[i]);
i++;
base = strtoul (argv[i], 0, 0);
}
else if (! strcmp (argv[i], "--list-size") ||
! strcmp (argv[i], "-l"))
{
if (i >= argc)
quit ("no parameter for %s", argv[i]);
i++;
list_size = strtoul (argv[i], 0, 0);
}
else if (! strcmp (argv[i], "--force") ||
! strcmp (argv[i], "-f"))
{
is_force = 1;
}
else if (! strcmp (argv[i], "--zip") ||
! strcmp (argv[i], "-z"))
{
is_zip = 1;
}
else if (! strcmp (argv[i], "--raw") ||
! strcmp (argv[i], "-r"))
{
is_raw = 1;
}
else if (! strcmp (argv[i], "--align") ||
! strcmp (argv[i], "-a"))
{
is_align = 1;
}
else if (! strcmp (argv[i], "--fat16"))
{
is_fat32 = 0;
}
else if (! strcmp (argv[i], "--fat32"))
{
is_fat32 = 1;
}
else if (! strcmp (argv[i], "--archive"))
{
if (i >= argc)
quit ("no parameter for %s", argv[i]);
i++;
ar_file = argv[i];
}
else if (! strcmp (argv[i], "--unit-size") ||
! strcmp (argv[i], "-u"))
{
if (i >= argc)
quit ("no parameter for %s", argv[i]);
i++;
unit_size = strtoul (argv[i], 0, 0);
}
else if (! strcmp (argv[i], "--max-sectors"))
{
if (i >= argc)
quit ("no parameter for %s", argv[i]);
i++;
max_sec = strtoul (argv[i], 0, 0);
}
else
quit ("invalid option %s for format", argv[i]);
}
data = (struct fb_data *) &fb_mbr_data[512];
if (ar_file)
{
int hd, ar_size;
struct fb_data *ar_data;
hd = open (ar_file, O_RDONLY | O_BINARY);
if (hd < 0)
quit ("can\'t open file %s", ar_file);
ar_data = (struct fb_data *) get_ar_header (hd, &ar_size);
if (! pri_size)
pri_size = ar_data->pri_size;
if (! ext_size)
ext_size = ar_data->ext_size;
if (! list_size)
{
int size;
int ofs;
ofs = (data->menu_ofs & 0x1ff);
size = (ofs + (ar_size << 9) - sizeof (struct fb_ar_data)) / 510;
list_size = size * 510 - ofs;
}
free (ar_data);
close (hd);
}
if (! pri_size)
pri_size = DEF_PRI_SIZE;
if (! list_size)
list_size = DEF_LIST_SIZE;
max_size = xd_size (xd);
if (max_size == XD_INVALID_SIZE)
quit ("can\'t get size");
total_size = (is_raw) ? base : ((pri_size + ext_size + 255) & ~255);
if (total_size >= max_size)
quit ("the disk is too small");
max_size -= total_size;
if (! part_size)
part_size = max_size;
else if (part_size > max_size)
quit ("size %s is too large", part_size);
if (is_fat32 == -1)
is_fat32 = (part_size >= DEF_FAT32_SIZE);
if (is_raw)
{
if (! is_force)
quit ("--raw would destroy existing partiiton layout,\n"
"use --force if you want to continue.");
if (base)
{
uchar4 part_start;
global_buffer[0x1be] = 0x80;
*((uchar2 *) &global_buffer[0x1fe]) = 0xaa55;
part_start = base;
lba2chs (part_start, &global_buffer[0x1bf]);
global_buffer[0x1c2] = (is_fat32) ? 0xc : 0xe;
lba2chs (part_start + part_size - 1, &global_buffer[0x1c3]);
*((uchar4 *) &global_buffer[0x1c6]) = part_start;
*((uchar4 *) &global_buffer[0x1ca]) = part_size;
write_disk (xd, global_buffer, 1);
memset (global_buffer, 0, 512);
if (base > 1)
zero_disk (xd, base - 1);
}
if (is_fat32)
format_fat32 (xd, part_size, unit_size, is_align);
else
format_fat16 (xd, part_size, unit_size, is_align);
return;
}
if (! is_force)
{
uchar4 min;
read_disk (xd, global_buffer, 1);
seek_disk (xd, 0);
min = get_part_ofs (global_buffer);
if (min == 0xffffffff)
is_force = 1;
else
{
if (min < pri_size + ext_size)
quit ("offset of data partition too small,\n"
"use --force to recreate disk layout");
if (! ext_size)
ext_size = min - pri_size;
}
}
if (is_force)
{
memset (&global_buffer, 0, 512);
global_buffer[0x1be] = 0x80;
lba2chs (total_size, &global_buffer[0x1bf]);
global_buffer[0x1c2] = (is_fat32) ? 0xc : 0xe;
lba2chs (total_size + part_size - 1, &global_buffer[0x1c3]);
*((uchar4 *) &global_buffer[0x1c6]) = total_size;
*((uchar4 *) &global_buffer[0x1ca]) = part_size;
}
m1 = (struct fb_mbr *) global_buffer;
m2 = (struct fb_mbr *) fb_mbr_data;
memcpy (global_buffer, fb_mbr_data, OFS_mbr_table);
memcpy (&global_buffer[510], &fb_mbr_data[510], data->menu_ofs + 2);
m1->boot_base = base;
m1->boot_size = data->menu_ofs >> 9;
m1->boot_size += ((data->menu_ofs & 0x1ff) + list_size + 509) / 510;
if (max_sec)
m1->max_sec = max_sec;
data = (struct fb_data *) &global_buffer[512];
data->pri_size = pri_size;
data->ext_size = ext_size;
if (is_zip)
{
global_buffer[0x26] = 0x29;
strcpy (&global_buffer[3], "MSWIN4.1");
}
sync_mbr (xd, global_buffer, base, 0);
for (i = 1; i <= m1->boot_size; i++)
*(uchar2 *) &global_buffer[i * 512 + 510] = base + i;
write_disk (xd, &global_buffer[512], m1->boot_size);
memset (global_buffer, 0, sizeof (global_buffer));
i += base;
while (i < pri_size)
{
int j, n;
n = pri_size - i;
if (n > GLOB_BUF_SIZE)
n = GLOB_BUF_SIZE;
for (j = 0; j < n; j++)
*((uchar2 *) &global_buffer[j * 512 + 510]) = i + j;
write_disk (xd, global_buffer, n);
i += n;
}
if (is_force)
{
seek_disk (xd, total_size);
memset (global_buffer, 0, sizeof (global_buffer));
if (is_fat32)
format_fat32 (xd, part_size, unit_size, is_align);
else
format_fat16 (xd, part_size, unit_size, is_align);
}
if (ar_file)
{
char * v[1];
seek_disk (xd, 0);
read_header (xd, 0);
v[0] = ar_file;
load_archive (xd, 1, v);
write_header (xd);
}
}
void
restore_disk (xd_t *xd)
{
struct fb_mbr *mbr;
int i;
mbr = (struct fb_mbr *) global_buffer;
for (i = 0; i < DEF_BASE_SIZE; i++)
{
read_disk (xd, (char *) mbr, 1);
if ((mbr->end_magic == 0xaa55) && (mbr->fb_magic == FB_MAGIC_LONG) &&
(mbr->lba == (uchar) i))
break;
}
if (i == DEF_BASE_SIZE)
quit ("can\'t find fb mbr");
if (i)
{
seek_disk (xd, 0);
read_disk (xd, &global_buffer[512], 1);
memcpy (&mbr->mbr_table, &global_buffer[512 + OFS_mbr_table],
0x200 - OFS_mbr_table);
sync_mbr (xd, (char *) mbr, i - 1, 0);
}
}
uchar4
get_ar_size ()
{
int last_ofs, ofs;
ofs = ((struct fb_data *) fb_list)->menu_ofs;
last_ofs = 0;
while (fb_list[ofs])
{
last_ofs = ofs;
ofs += fb_list[ofs] + 2;
}
if (last_ofs)
{
struct fbm_file *m;
int n;
m = (struct fbm_file *) (fb_list + last_ofs);
n = (m->data_start >= fb_pri_size) ? 512 : 510;
return m->data_start + (m->data_size + n - 1) / n;
}
else
return fb_boot_size;
}
void
read_header (xd_t *xd, int allow_ar)
{
struct fb_mbr *m1, *m2;
struct fb_data *d1, *d2;
read_disk (xd, global_buffer, 1);
m1 = (struct fb_mbr *) global_buffer;
m2 = (struct fb_mbr *) fb_mbr_data;
if (m1->fb_magic != m2->fb_magic)
{
if (((struct fb_ar_data *) global_buffer)->ar_magic == FB_AR_MAGIC_LONG)
{
if (! allow_ar)
quit ("this command can\'t work with archive");
fb_boot_base = -1;
fb_boot_size = ((struct fb_ar_data *) global_buffer)->boot_size;
fb_ar_mode = 1;
}
else
quit ("fb mbr not detected");
}
else
{
fb_boot_base = m1->boot_base;
fb_boot_size = m1->boot_size;
fb_part_ofs = *((uchar4 *) &global_buffer[0x1c6]);
}
fb_list = xmalloc (fb_boot_size << 9);
seek_disk (xd, fb_boot_base + 1);
read_disk (xd, fb_list, fb_boot_size);
d1 = (struct fb_data *) fb_list;
d2 = (struct fb_data *) (fb_mbr_data + 512);
if ((d1->ver_major != d2->ver_major) ||
(d1->ver_minor != d2->ver_minor))
quit ("version number not match");
if (fb_ar_mode)
{
fb_pri_size = fb_boot_size;
fb_total_size = FB_AR_MAX_SIZE;
d1->menu_ofs = sizeof (struct fb_ar_data);
fb_list_size = fb_boot_size << 9;
}
else
{
unsigned int i;
char *p;
fb_pri_size = d1->pri_size;
fb_total_size = d1->pri_size + d1->ext_size;
i = (d1->menu_ofs >> 9) + 1;
p = fb_list + i * 512 - 2;
for (; i < fb_boot_size; i++)
{
memcpy (p, fb_list + i * 512, 510);
p += 510;
}
fb_list_size = p - (char *) fb_list;
}
fb_list_tail = d1->menu_ofs;
while (fb_list[fb_list_tail])
{
if (fb_list[fb_list_tail + 1] != FBM_TYPE_FILE)
quit ("invalid file list");
fb_list_tail += fb_list[fb_list_tail] + 2;
if (fb_list_tail >= fb_list_size)
quit ("invalid file list");
}
if (fb_ar_mode)
fb_ar_size = get_ar_size ();
}
void
write_header (xd_t *xd)
{
struct fb_data *data;
memset (fb_list + fb_list_tail, 0, fb_list_size - fb_list_tail);
data = (struct fb_data *) fb_list;
if (! fb_ar_mode)
{
unsigned int i, n;
char *p;
n = (data->menu_ofs >> 9) + 1;
p = (fb_list + (fb_boot_size - 1) * 512 - (fb_boot_size - n) * 2);
for (i = fb_boot_size - 1; i >= n; i--)
{
memcpy (fb_list + i * 512, p, 510);
p -= 510;
*((uchar2 *) (fb_list + i * 512 - 2)) = fb_boot_base + i;
}
}
else
data->menu_ofs = FB_AR_MAGIC_WORD;
seek_disk (xd, fb_boot_base + 1);
write_disk (xd, fb_list, fb_boot_size);
#ifdef WIN32
if (fb_ar_mode)
{
uchar4 size;
data->menu_ofs = sizeof (struct fb_ar_data);
size = get_ar_size ();
if ((size < fb_ar_size) && ((xd->flg & XDF_FILE) != 0) &&
((xd->flg & XDF_DISK) == 0))
{
seek_disk (xd, size);
SetEndOfFile ((HANDLE) xd->num);
}
}
#endif
}
void
update_header (xd_t *xd)
{
uchar4 i;
struct fb_mbr *m2;
struct fb_data *d1, *d2;
int boot_size, menu_ofs;
m2 = (struct fb_mbr *) fb_mbr_data;
d2 = (struct fb_data *) &fb_mbr_data[512];
d1 = (struct fb_data *) fb_list;
menu_ofs = d1->menu_ofs;
boot_size = d2->menu_ofs >> 9;
boot_size += ((d2->menu_ofs & 0x1ff) +
fb_list_tail - menu_ofs + 1 + 509) / 510;
if (boot_size > fb_boot_size)
quit ("not enough space for menu, you need to use format command");
seek_disk (xd, 0);
for (i = 0; i <= fb_boot_base; i++)
{
int ofs;
struct fb_mbr *m1;
read_disk (xd, global_buffer, 1);
ofs = m2->jmp_ofs + 2;
memcpy (&global_buffer[ofs], &fb_mbr_data[ofs],
sizeof (m2->boot_code) + 2 - ofs);
m1 = (struct fb_mbr *) global_buffer;
m1->jmp_ofs = m2->jmp_ofs;
seek_disk (xd, i);
write_disk (xd, global_buffer, 1);
}
memset (global_buffer, 0, fb_boot_size * 512);
memcpy (global_buffer, &fb_mbr_data[512], d2->menu_ofs);
memcpy (global_buffer + 2, fb_list + 2, sizeof (struct fb_data) - 2);
memcpy (&global_buffer[d2->menu_ofs], fb_list + menu_ofs,
fb_list_tail - menu_ofs);
fb_list_tail += d2->menu_ofs - menu_ofs;
memcpy (fb_list, global_buffer, fb_list_tail);
for (i = 0; i < (d2->menu_ofs >> 9); i++)
*((uchar2 *) (fb_list + i * 512 + 510)) =
fb_boot_base + 1 + i;
*((uchar2 *) (fb_list + fb_boot_size * 512 - 2)) =
fb_boot_base + fb_boot_size;
}
void
sync_disk (xd_t *xd, int argc, char **argv)
{
uchar4 start;
char buf[512];
int copy_bpb = -1;
int bpb_size = 0;
int i, jmp_ofs;
for (i = 0; i < argc; i++)
{
if (argv[i][0] != '-')
break;
if (! strcmp (argv[i], "--copy-bpb"))
{
copy_bpb = 1;
}
else if (! strcmp (argv[i], "--clear-bpb"))
{
copy_bpb = 0;
}
else if (! strcmp (argv[i], "--bpb-size"))
{
if (i >= argc)
quit ("no parameter for %s", argv[i]);
i++;
bpb_size = strtoul (argv[i], 0, 0);
}
else
quit ("invalid option %s for sync", argv[i]);
}
seek_disk (xd, 0);
read_disk (xd, global_buffer, 1);
start = get_part_ofs (global_buffer);
seek_disk (xd, start);
read_disk (xd, buf, 1);
jmp_ofs = global_buffer[1];
if (copy_bpb == 1)
{
struct fat_bs16 *bs;
uchar4 ts;
bs = (struct fat_bs16 *) global_buffer;
memcpy (&global_buffer[2], &buf[2], jmp_ofs);
bs->nrs += start;
bs->nhs = 0;
ts = ((struct fat_bs16 *) buf)->ts16;
if (! ts)
ts = ((struct fat_bs16 *) buf)->ts32;
ts += start;
bs->ts16 = 0;
bs->ts32 = 0;
if (ts < 65536)
bs->ts16 = (uchar2) ts;
else
bs->ts32 = ts;
}
else if (copy_bpb == 0)
memset (&global_buffer[2], 0, jmp_ofs);
if ((bpb_size) && (bpb_size < jmp_ofs + 2))
memset (&global_buffer[bpb_size], 0, jmp_ofs + 2 - bpb_size);
sync_mbr (xd, global_buffer, fb_boot_base, copy_bpb == 1);
}
void
print_info ()
{
int o;
struct fb_data *data;
uchar4 s1, s2, b;
data = (struct fb_data *) fb_list;
printf ("version: %d.%d\n", data->ver_major, data->ver_minor);
if (! fb_ar_mode)
{
printf ("base boot sector: %d\n", fb_boot_base);
printf ("extra data size: %d\n", fb_boot_size);
printf ("primary data size: %lu\n", data->pri_size);
printf ("extended data size: %lu\n", data->ext_size);
printf ("menu offset: 0x%x\n", data->menu_ofs);
}
else
{
printf ("file list size: %d\n", fb_boot_size);
printf ("original primary data size: %ld\n", data->pri_size);
printf ("original extended data size: %ld\n", data->ext_size);
printf ("total sectors: %d\n", fb_ar_size);
}
printf ("files:\n");
o = data->menu_ofs;
b = fb_boot_base + 1 + fb_boot_size;
s1 = 0;
s2 = 0;
while (fb_list[o])
{
struct fbm_file *m;
struct tm *tm;
int n;
m = (struct fbm_file *) (fb_list + o);
if (m->data_start < fb_pri_size)
{
n = (m->data_size + 509) / 510;
s1 += n;
}
else
{
n = (m->data_size + 511) >> 9;
s2 += n;
}
if (m->data_start != b)
{
if ((b >= fb_pri_size) || (m->data_start <= fb_pri_size))
printf (" %d* 0x%lx 0x%lx\n",
b >= fb_pri_size,
b, m->data_start - b);
else
{
printf (" 0* 0x%lx 0x%lx\n", b, fb_pri_size - b);
printf (" 1* 0x%lx 0x%lx\n", fb_pri_size,
m->data_start - fb_pri_size);
}
}
b = m->data_start + n;
tm = localtime (&m->data_time);
printf (" %d%c%c \"%s\" 0x%lx %ld "
"(%d-%02d-%02d %02d:%02d:%02d)\n",
(m->data_start >= fb_pri_size),
(m->flag & FBF_FLAG_EXTENDED) ? 'e' : ' ',
(m->flag & FBF_FLAG_SYSLINUX) ? 's' : ' ',
m->name, m->data_start, m->data_size,
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec);
o += fb_list[o] + 2;
}
if (! fb_ar_mode)
{
if (b != fb_total_size)
printf (" 1* 0x%lx 0x%lx\n", b, fb_total_size - b);
printf ("primary area free space: %ld\n",
(fb_pri_size - fb_boot_base - 1 - fb_boot_size - s1) * 510);
printf ("extended area free space: %ld\n",
(data->ext_size - s2) * 512);
}
}
void
clear_menu ()
{
fb_list_tail = ((struct fb_data *) fb_list)->menu_ofs;
}
int
check_space (uchar4* start, uchar4 size, uchar4 *count,
uchar4 begin, uchar4 end, int is_ext)
{
if ((begin >= fb_pri_size) || (end <= fb_pri_size))
{
if (((begin >= fb_pri_size) || (! is_ext)) && (end - begin >= *count))
{
*start = begin;
return 1;
}
}
else
{
if ((! is_ext) && (fb_pri_size - begin >= *count))
{
*start = begin;
return 1;
}
*count = (size + 511) >> 9;
if (end - fb_pri_size >= *count)
{
*start = fb_pri_size;
return 1;
}
}
return 0;
}
int
find_space (uchar4* start, uchar4 size, int is_ext)
{
int ofs;
uchar4 begin, count;
begin = fb_boot_base + 1 + fb_boot_size;
count = (size + 509) / 510;
ofs = ((struct fb_data *) fb_list)->menu_ofs;
while (fb_list[ofs])
{
struct fbm_file *m;
int n;
m = (struct fbm_file *) (fb_list + ofs);
if (check_space (start, size, &count, begin, m->data_start, is_ext))
return ofs;
n = (m->data_start >= fb_pri_size) ? 512 : 510;
begin = m->data_start + (m->data_size + n - 1) / n;
ofs += fb_list[ofs] + 2;
}
if (! check_space (start, size, &count, begin, fb_total_size, is_ext))
quit ("not enough space");
return ofs;
}
char *
get_name (char *name)
{
while (*name == '/')
name++;
if (! *name)
quit ("empty file name");
return name;
}
struct fbm_file *
find_file (char *name)
{
int ofs;
name = get_name (name);
ofs = ((struct fb_data *) fb_list)->menu_ofs;
while (fb_list[ofs])
{
struct fbm_file *m;
m = (struct fbm_file *) (fb_list + ofs);
if (! stricmp (m->name, name))
return m;
ofs += fb_list[ofs] + 2;
}
return 0;
}
int
del_file (char *name)
{
struct fbm_file *m;
char *p;
int len;
m = find_file (get_name (name));
if (! m)
return 0;
len = m->size + 2;
p = (char *) m;
memcpy (p, p + len, (char *) (fb_list + fb_list_tail) - (char *) (p + len));
fb_list_tail -= len;
*(fb_list + fb_list_tail) = 0;
return 1;
}
struct fbm_file *
alloc_file (char *in_name, uchar4 *start, uchar4 size, int is_ext, time_t tm)
{
int len, ofs;
struct fbm_file *m;
in_name = get_name (in_name);
del_file (in_name);
len = sizeof (struct fbm_file) + strlen (in_name) + 1;
if ((len > 255) || (fb_list_tail + len >= fb_list_size))
quit ("file item too long");
ofs = find_space (start, size, is_ext);
if (ofs < fb_list_tail)
memcpy (fb_list + ofs + len, fb_list + ofs, fb_list_tail - ofs);
m = (struct fbm_file *) (fb_list + ofs);
m->size = len - 2;
m->type = FBM_TYPE_FILE;
m->data_start = *start;
m->data_size = size;
m->data_time = tm;
m->flag = (is_ext) ? FBF_FLAG_EXTENDED : 0;
strcpy (m->name, in_name);
fb_list_tail += len;
return m;
}
void
cpy_file (xd_t *xd, char *name, uchar4 size,
uchar4 old_start, uchar4 old_size,
int is_ext, int fill, time_t tm)
{
int block_size;
uchar4 start;
struct fbm_file *m;
m = alloc_file (name, &start, size, is_ext, tm);
if (! old_size)
is_ext = (start >= fb_pri_size);
else if (is_ext != (start >= fb_pri_size))
quit ("not enough space");
block_size = (is_ext) ? 512 : 510;
size = (size + block_size - 1) / block_size;
if (old_size)
{
int num;
num = old_size / block_size;
if (start != old_start)
copy_disk (xd, start, old_start, num);
start += num;
old_start += num;
size -= num;
old_size %= block_size;
if (old_size)
{
seek_disk (xd, old_start);
read_disk (xd, global_buffer, 1);
memset (&global_buffer[old_size], fill, block_size - old_size);
if (! is_ext)
*((uchar2 *) &global_buffer[510]) = start;
seek_disk (xd, start);
write_disk (xd, global_buffer, 1);
start++;
size--;
}
}
xd_seek (xd, start);
memset (global_buffer, fill, sizeof (global_buffer));
while (size)
{
int n;
n = (size > GLOB_BUF_SIZE) ? GLOB_BUF_SIZE : size;
if (! is_ext)
{
int i;
for (i = 0; i < n; i++)
*((uchar2 *) &global_buffer[i * 512 + 510]) = start + i;
}
write_disk (xd, global_buffer, n);
start += n;
size -= n;
}
}
void
save_file_data (xd_t *xd, struct fbm_file *m, int hd)
{
uchar4 start, size;
int n;
start = m->data_start;
seek_disk (xd, start);
size = m->data_size;
n = (start >= fb_pri_size) ? 512 : 510;
while (size)
{
uchar4 nb, ns, i;
char *p;
nb = (size > GLOB_BUF_SIZE * n) ? GLOB_BUF_SIZE * n : size;
ns = (nb + n - 1) / n;
p = global_buffer;
if (n == 512)
{
if (read (hd, global_buffer, nb) != nb)
quit ("file read fails");
}
else
{
for (i = 0; i < ns; i++, start++)
{
int nr;
nr = (i == (ns - 1)) ? nb - i * 510 : 510;
if (read (hd, &global_buffer[i * 512], nr) != nr)
quit ("file read fails");
*((uchar2 *) &global_buffer[i * 512 + 510]) = start;
}
}
write_disk (xd, global_buffer, ns);
size -= nb;
}
}
struct fbm_file *
save_file (xd_t *xd, char *in_name, char *name, int is_ext)
{
struct stat st;
int hd;
uchar4 start, size;
struct fbm_file *m;
hd = open (name, O_RDONLY | O_BINARY);
if (hd < 0)
quit ("can\'t open file %s", name);
if (fstat (hd, &st) < 0)
quit ("can\'t get file stat");
size = st.st_size;
if (! size)
quit ("empty file %s", name);
m = alloc_file (in_name, &start, size, is_ext, st.st_mtime);
save_file_data (xd, m, hd);
close (hd);
return m;
}
void
load_file_data (xd_t *xd, struct fbm_file *m, int hd)
{
int n;
uchar4 size;
seek_disk (xd, m->data_start);
size = m->data_size;
n = (m->data_start >= fb_pri_size) ? 512 : 510;
while (size)
{
uchar4 nb, ns, i;
nb = (size > GLOB_BUF_SIZE * n) ? GLOB_BUF_SIZE * n : size;
ns = (nb + n - 1) / n;
read_disk (xd, global_buffer, ns);
if (n == 512)
{
if (write (hd, global_buffer, nb) != nb)
quit ("file write fails");
}
else
{
for (i = 0; i < ns; i++)
{
int nw;
nw = (i == (ns - 1)) ? nb - i * 510 : 510;
if (write (hd, &global_buffer[i * 512], nw) != nw)
quit ("file write fails");
}
}
size -= nb;
}
}
void
load_file (xd_t *xd, char *in_name, char *name)
{
struct fbm_file *m;
int hd;
m = find_file (in_name);
if (! m)
quit ("file %s not found", in_name);
hd = open (name, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0666);
if (hd < 0)
quit ("can\'t write to file %s", name);
load_file_data (xd, m, hd);
close (hd);
}
void
save_buff (xd_t *xd, char *in_name, uchar4 size, int is_ext)
{
uchar4 start;
alloc_file (in_name, &start, size, 0, time (0));
seek_disk (xd, start);
if (start >= fb_pri_size)
{
write_disk (xd, global_buffer, (size + 511) >> 9);
}
else
{
int ns;
char *p;
p = global_buffer;
ns = (size + 509) / 510;
while (ns)
{
uchar2 saved;
saved = *((uchar2 *) (p + 510));
*((uchar2 *) (p + 510)) = start;
write_disk (xd, p, 1);
*((uchar2 *) (p + 510)) = saved;
start++;
ns--;
}
}
}
int
load_buff (xd_t *xd, char *in_name)
{
struct fbm_file *m;
m = find_file (in_name);
if (! m)
quit ("file %s not found", in_name);
if (m->data_size > sizeof (global_buffer))
quit ("file %s too large", in_name);
seek_disk (xd, m->data_start);
if (m->data_start >= fb_pri_size)
{
read_disk (xd, global_buffer, (m->data_size + 511) >> 9);
}
else
{
int ns;
char *p;
p = global_buffer;
ns = (m->data_size + 509) / 510;
while (ns)
{
read_disk (xd, p, 1);
p += 510;
ns--;
}
}
return m->data_size;
}
#define LDLINUX_MAGIC 0x3eb202fe
void
syslinux_patch (xd_t *xd, struct fbm_file *m)
{
int dw, i;
uchar4 start, cs, *p;
char *pa;
int ns;
m->flag |= FBF_FLAG_SYSLINUX;
ns = (m->data_size + 511) >> 9;
if ((ns <= 2) || (ns > GLOB_BUF_SIZE))
quit ("invalid size for ldlinux.bin");
seek_disk (xd, m->data_start);
read_disk (xd, global_buffer, ns);
start = m->data_start + 1;
*((uchar4 *) &global_buffer[0x1f8]) = start - fb_part_ofs;
*((uchar2 *) &global_buffer[0x1fe]) = 0xaa55;
pa = &global_buffer[0x200];
while ((*((uchar4 *) pa) != LDLINUX_MAGIC) &&
(pa < (char *) &global_buffer[0x400]))
pa += 4;
if (pa >= (char *) &global_buffer[0x400])
quit ("syslinux signature not found");
dw = (m->data_size - 512) >> 2;
pa += 8;
*((uchar2 *) pa) = dw;
p = (uchar4 *) (pa + 8);
memset (p, 0, 64 * 4);
#if SYSLINUX_FULL_LOAD
start++;
ns -= 2;
*((uchar2 *) (pa + 2)) = ns;
while (ns)
{
*p = start - fb_part_ofs;
start++;
ns--;
p++;
}
#else
*((uchar2 *) (pa + 2)) = 0;
#endif
*((uchar4 *) (pa + 4)) = 0;
cs = LDLINUX_MAGIC;
for (i = 0, p = (uchar4 *) &global_buffer[0x200]; i < dw; i++, p++)
cs -= *p;
*((uchar4 *) (pa + 4)) = cs;
seek_disk (xd, m->data_start);
write_disk (xd, global_buffer, 2);
}
void
add_file (xd_t *xd, int argc, char **argv)
{
int i, is_ext, is_syslinux;
struct fbm_file *m;
is_ext = 0;
is_syslinux = 0;
for (i = 0; i < argc; i++)
{
if (argv[i][0] != '-')
break;
if (! strcmp (argv[i], "--extended") ||
! strcmp (argv[i], "-e"))
{
is_ext = 1;
}
else if (! strcmp (argv[i], "--syslinux") ||
! strcmp (argv[i], "-s"))
{
is_syslinux = 1;
is_ext = 1;
}
else
quit ("invalid option %s for add", argv[i]);
}
argc -= i;
argv += i;
if (argc < 2)
quit ("not enough parameters");
m = save_file (xd, argv[0], argv[1], is_ext);
if (is_syslinux)
syslinux_patch (xd, m);
}
int
add_item_menu (int ofs, int argc, char **argv)
{
int size, type;
struct fbm_menu *m;
if (argc < 2)
quit ("not enough parameters");
type = 0;
size = sizeof (struct fbm_menu);
if ((! strcmp (argv[1], "grldr")) ||
(! strcmp (argv[1], "syslinux")) ||
(! strcmp (argv[1], "msdos")))
{
if (argc < 3)
quit ("not enough parameters");
switch (argv[1][0])
{
case 'g':
type = FBS_TYPE_GRLDR;
break;
case 's':
type = FBS_TYPE_SYSLINUX;
break;
case 'm':
type = FBS_TYPE_MSDOS;
break;
}
size += strlen (get_name (argv[2])) + 1;
}
else if (! strcmp (argv[1], "linux"))
{
if (argc < 3)
quit ("not enough parameters");
type = FBS_TYPE_LINUX;
size += strlen (get_name (argv[2])) + 1;
if (argc >= 4)
size += strlen (argv[3]) + 1;
else
size++;
if (argc >= 5)
size += strlen (argv[4]) + 1;
else
size++;
}
else
quit ("invalid system type %s", argv[1]);
if ((size > 255) || (ofs + size >= sizeof (global_buffer) - 512))
quit ("menu item too long");
m = (struct fbm_menu *) &global_buffer[ofs];
m->size = size - 2;
m->type = FBM_TYPE_MENU;
m->sys_type = type;
m->key = get_keycode (argv[0]);
if (! m->key)
quit ("invalid hotkey %s", argv[0]);
switch (type)
{
case FBS_TYPE_GRLDR:
case FBS_TYPE_SYSLINUX:
case FBS_TYPE_MSDOS:
strcpy (m->name, get_name (argv[2]));
break;
case FBS_TYPE_LINUX:
{
char *p;
p = m->name;
strcpy (p, get_name (argv[2]));
p += strlen (p) + 1;
if (argc >= 4)
strcpy (p, argv[3]);
else
*p = 0;
p += strlen (p) + 1;
if (argc >= 5)
strcpy (p, argv[4]);
else
*p = 0;
break;
}
}
return ofs + size;
}
int
add_item_text (int ofs, int argc, char **argv)
{
int size, i, has_newline;
struct fbm_text *m;
char *p;
has_newline = 1;
if ((argc > 0) && (! strcmp (argv[0], "-n")))
{
has_newline = 0;
argc--;
argv++;
}
size = sizeof (struct fbm_text);
for (i = 0; i < argc; i++)
size += strlen (argv[i]) + 1;
if (has_newline)
size += 2;
if ((size > 255) || (ofs + size >= sizeof (global_buffer) - 512))
quit ("text item too long");
m = (struct fbm_text *) &global_buffer[ofs];
m->size = size - 2;
m->type = FBM_TYPE_TEXT;
p = m->title;
for (i = 0; i < argc; i++)
{
strcpy (p, argv[i]);
p += strlen (argv[i]);
*(p++) = ' ';
}
p--;
if (has_newline)
{
*(p++) = '\r';
*(p++) = '\n';
}
*p = 0;
return ofs + size;
}
static char *color_list[16] =
{
"black",
"blue",
"green",
"cyan",
"red",
"magenta",
"brown",
"light-gray",
"dark-gray",
"light-blue",
"light-green",
"light-cyan",
"light-red",
"light-magenta",
"yellow",
"white"
};
int
name2color (char *name)
{
int i;
for (i = 0; i < sizeof (color_list) / sizeof (*color_list); i++)
if (! strcmp (name, color_list[i]))
return i;
return -1;
}
int
get_color_value (char *name)
{
int fg, bg;
char *p;
if (! strcmp (name, "normal"))
return COLOR_NORMAL;
p = strchr (name, '/');
if (p)
{
*(p++) = 0;
bg = name2color (p);
if (bg < 0)
quit ("invalid background color %s", p);
}
else
bg = 0;
fg = name2color (name);
if (fg < 0)
quit ("invalid foreground color %s", name);
return (bg << 4) + fg;
}
static char color_name[32];
char *
get_color_name (uchar4 color)
{
int fg, bg;
if (color == COLOR_NORMAL)
return "normal";
fg = color & 0xf;
bg = color >> 4;
if (! bg)
return color_list[fg];
sprintf (color_name, "%s/%s", color_list [fg], color_list[bg]);
return color_name;
}
int
add_item_timeout (int ofs, int argc, char **argv, uchar type)
{
int size;
struct fbm_timeout *m;
if (argc < 1)
quit ("not enough parameters");
size = sizeof (struct fbm_timeout);
if (ofs + size >= sizeof (global_buffer) - 512)
quit ("menu item too long");
m = (struct fbm_timeout *) &global_buffer[ofs];
m->size = size - 2;
m->type = type;
m->timeout = ((type == FBM_TYPE_COLOR) ? get_color_value (argv[0]) :
strtoul (argv[0], 0, 0));
return ofs + size;
}
#define PARSE_LINE_ARGS_STEP 10
int
parse_line (char *line, char ***args)
{
char **v;
int n, max;
n = 0;
max = 0;
v = 0;
while (*line)
{
char *p;
while ((*line == ' ') || (*line == '\t') ||
(*line == '\r') || (*line == '\n'))
line++;
if (! *line)
break;
p = line;
if (*line == '\"')
{
p++;
line++;
while ((*line) && (*line != '\"'))
line++;
}
else
{
while ((*line) && (*line != ' ') && (*line != '\t') &&
(*line != '\r') && (*line != '\n'))
line++;
}
if (*line)
{
*line = 0;
line++;
}
if (n == max)
{
v = realloc (v, max + PARSE_LINE_ARGS_STEP);
if (! v)
quit ("not enough memory");
max += PARSE_LINE_ARGS_STEP;
}
v[n] = p;
n++;
}
*args = v;
return n;
}
int
add_menu_line (int ofs, char *line)
{
int n;
char **v;
if (line[0] == '#')
return ofs;
n = parse_line (line, &v);
if (! n)
return ofs;
if (! strcmp (v[0], "menu"))
ofs = add_item_menu (ofs, n - 1, v + 1);
else if (! strcmp (v[0], "text"))
ofs = add_item_text (ofs, n - 1, v + 1);
else if (! strcmp (v[0], "timeout"))
ofs = add_item_timeout (ofs, n - 1, v + 1, FBM_TYPE_TIMEOUT);
else if (! strcmp (v[0], "default"))
ofs = add_item_timeout (ofs, n - 1, v + 1, FBM_TYPE_DEFAULT);
else if (! strcmp (v[0], "color"))
ofs = add_item_timeout (ofs, n - 1, v + 1, FBM_TYPE_COLOR);
else
quit ("unknown menu command");
free (v);
return ofs;
}
void
add_menu (xd_t *xd, int argc, char **argv)
{
FILE *f;
char line[512];
int i, ofs;
int is_append = 0;
int is_direct = 0;
for (i = 0; i < argc; i++)
{
if (argv[i][0] != '-')
break;
if (! strcmp (argv[i], "--append") ||
! strcmp (argv[i], "-a"))
{
is_append = 1;
}
else if (! strcmp (argv[i], "--string") ||
! strcmp (argv[i], "-s"))
{
is_direct = 1;
}
else
quit ("invalid option %s for add-menu", argv[i]);
}
argc -= i;
argv += i;
if (argc < 2)
quit ("not enough parameters");
if ((is_append) && (find_file (argv[0])))
ofs = load_buff (xd, argv[0]) - 1;
else
ofs = 0;
if (is_direct)
{
for (i = 1; i < argc; i++)
ofs = add_menu_line (ofs, argv[i]);
}
else
{
f = fopen (argv[1], "r");
if (! f)
quit ("can\'t open file %s", argv[1]);
while (fgets (line, sizeof (line), f))
ofs = add_menu_line (ofs, line);
fclose (f);
}
global_buffer[ofs] = 0;
save_buff (xd, argv[0], ofs + 1, 0);
}
void
resize_file (xd_t *xd, int argc, char **argv)
{
int fill = 0;
int is_ext = 0;
struct fbm_file *m;
uchar4 size, old_start, old_size;
int i;
char *name;
for (i = 0; i < argc; i++)
{
if (argv[i][0] != '-')
break;
if (! strcmp (argv[i], "--extended") ||
! strcmp (argv[i], "-e"))
{
is_ext = 1;
}
else if (! strcmp (argv[i], "--fill") ||
! strcmp (argv[i], "-f"))
{
if (i >= argc)
quit ("no parameter for %s", argv[i]);
i++;
if (strlen (argv[i]) == 1)
fill = argv[i][0];
else
fill = strtoul (argv[i], 0, 0);
}
else
quit ("invalid option %s for resize", argv[i]);
}
argc -= i;
argv += i;
if (argc < 2)
quit ("not enough parameters");
size = strtoul (argv[1], 0, 0);
if (! size)
quit ("invalid size");
name = get_name (argv[0]);
m = find_file (name);
if (m)
{
if (m->data_size >= size)
{
m->data_size = size;
return;
}
is_ext = (m->data_start >= fb_pri_size);
old_start = m->data_start;
old_size = m->data_size;
del_file (name);
}
else
{
old_start = 0;
old_size = 0;
}
cpy_file (xd, name, size, old_start, old_size, is_ext, fill, time (0));
}
void
copy_file (xd_t *xd, int argc, char **argv)
{
struct fbm_file *m;
del_file (argv[1]);
m = find_file (argv[0]);
if (! m)
quit ("file %s not found", argv[0]);
cpy_file (xd, get_name (argv[1]), m->data_size,
m->data_start, m->data_size,
m->data_start >= fb_pri_size, 0, m->data_time);
}
void
move_file (xd_t *xd, int argc, char **argv)
{
struct fbm_file *m;
int old_len, len;
char *name;
if (argc < 2)
quit ("not enough parameters");
del_file (argv[1]);
m = find_file (argv[0]);
if (! m)
quit ("file %s not found", argv[0]);
name = get_name (argv[1]);
len = sizeof (struct fbm_file) + strlen (name) + 1;
old_len = m->size + 2;
if ((len > 255) || (fb_list_tail + len - old_len >= fb_list_size))
quit ("file item too long");
if (len != old_len)
{
char *p;
p = (char *) m;
memcpy (p + len, p + old_len,
(char *) (fb_list + fb_list_tail) - (char *) (p + old_len));
fb_list_tail += len - old_len;
*(fb_list + fb_list_tail) = 0;
m->size = len - 2;
}
strcpy (m->name, name);
}
void
export_file (xd_t *xd, int argc, char **argv)
{
if (argc < 2)
quit ("not enough parameters");
load_file (xd, argv[0], argv[1]);
}
void
remove_file (xd_t *xd, int argc, char **argv)
{
if (argc < 1)
quit ("not enough parameters");
if (! del_file (argv[0]))
quit ("file %s not found", argv[0]);
}
void
cat_file (xd_t *xd, int argc, char **argv)
{
int len;
if (argc < 1)
quit ("not enough parameters");
len = load_buff (xd, argv[0]);
global_buffer[len] = 0;
puts (global_buffer);
}
void
cat_menu (xd_t *xd, int argc, char **argv)
{
int o, len;
if (argc < 1)
quit ("not enough parameters");
len = load_buff (xd, argv[0]);
o = 0;
while (global_buffer[o])
{
switch (global_buffer[o + 1])
{
case FBM_TYPE_MENU:
{
struct fbm_menu *m;
m = (struct fbm_menu *) &global_buffer[o];
printf ("menu %s ", get_keyname (m->key));
switch (m->sys_type)
{
case FBS_TYPE_GRLDR:
printf ("grldr \"%s\"\n", m->name);
break;
case FBS_TYPE_SYSLINUX:
printf ("syslinux \"%s\"\n", m->name);
break;
case FBS_TYPE_LINUX:
{
char *p1, *p2;
p1 = m->name + strlen (m->name) + 1;
p2 = p1 + strlen (p1) + 1;
printf ("linux \"%s\" \"%s\" \"%s\"\n", m->name, p1, p2);
break;
}
case FBS_TYPE_MSDOS:
printf ("msdos \"%s\"\n", m->name);
break;
default:
quit ("invalid system type %d", m->sys_type);
}
break;
}
case FBM_TYPE_TEXT:
{
struct fbm_text *m;
int text_len, has_newline;
m = (struct fbm_text *) &global_buffer[o];
text_len = strlen (m->title);
has_newline = 0;
if ((text_len >= 2) &&
(m->title[text_len - 1] == '\n') &&
(m->title[text_len - 2] == '\r'))
{
has_newline = 1;
m->title[text_len - 2] = 0;
}
printf ("text %s\"%s\"\n", (has_newline) ? "" : "-n ", m->title);
break;
}
case FBM_TYPE_TIMEOUT:
case FBM_TYPE_DEFAULT:
{
struct fbm_timeout *m;
int is_timeout;
is_timeout = (global_buffer[o + 1] == FBM_TYPE_TIMEOUT);
m = (struct fbm_timeout *) &global_buffer[o];
printf ("%s %d\n", (is_timeout) ? "timeout" : "default",
m->timeout);
break;
}
case FBM_TYPE_COLOR:
{
struct fbm_timeout *m;
m = (struct fbm_timeout *) &global_buffer[o];
printf ("color %s\n", get_color_name (m->timeout));
break;
}
default:
quit ("invalid menu type %d", global_buffer[o + 1]);
}
o += global_buffer[o] + 2;
if (o >= len)
quit ("invalid menu");
}
}
void
pack_disk (xd_t *xd)
{
uchar4 b;
int ofs;
b = fb_boot_base + 1 + fb_boot_size;
ofs = ((struct fb_data *) fb_list)->menu_ofs;
while (fb_list[ofs])
{
struct fbm_file *m;
int n;
m = (struct fbm_file *) (fb_list + ofs);
if (m->data_start < fb_pri_size)
n = (m->data_size + 509) / 510;
else
n = (m->data_size + 511) >> 9;
if ((b < fb_pri_size) && (m->data_start >= fb_pri_size))
b = fb_pri_size;
if (m->data_start != b)
{
copy_disk (xd, b, m->data_start, n);
m->data_start = b;
}
b = m->data_start + n;
ofs += fb_list[ofs] + 2;
}
}
void
check_disk (xd_t *xd)
{
int start;
seek_disk (xd, 0);
start = 0;
while (start < fb_pri_size)
{
int i, n;
n = fb_pri_size - start;
if (n > GLOB_BUF_SIZE)
n = GLOB_BUF_SIZE;
read_disk (xd, global_buffer, n);
for (i = 0; i < n; i++, start++)
{
struct fb_mbr *mbr;
int b;
mbr = (struct fb_mbr *) &global_buffer[i * 512];
if (start <= fb_boot_base)
b = ((mbr->end_magic != 0xaa55) || (mbr->lba != start));
else
b = (mbr->end_magic != start);
if (b)
quit ("check fail at sector %d", start);
}
}
}
void
save_archive (xd_t *xd, int argc, char **argv)
{
uchar *buf;
int i, hd, o1, o2, start;
int list_size;
struct fb_ar_data *data;
list_size = 0;
for (i = 0; i < argc; i++)
{
if (argv[i][0] != '-')
break;
if (! strcmp (argv[i], "--list-size") ||
! strcmp (argv[i], "-l"))
{
if (i >= argc)
quit ("no parameter for %s", argv[i]);
i++;
list_size = strtoul (argv[i], 0, 0);
}
else
quit ("invalid option %s for save", argv[i]);
}
argc -= i;
argv += i;
if (argc < 1)
quit ("not enough parameters");
if (! list_size)
list_size = fb_list_size - ((struct fb_data *) fb_list)->menu_ofs;
list_size = (list_size + sizeof (struct fb_ar_data) + 511) & ~511;
start = (list_size >> 9);
buf = xmalloc (list_size);
data = (struct fb_ar_data *) buf;
data->ar_magic = FB_AR_MAGIC_LONG;
data->ver_major = VER_MAJOR;
data->ver_minor = VER_MINOR;
data->pri_size = ((struct fb_data *) fb_list)->pri_size;
data->ext_size = ((struct fb_data *) fb_list)->ext_size;
data->boot_size = start;
o1 = ((struct fb_data *) fb_list)->menu_ofs;
o2 = sizeof (struct fb_ar_data);
while (fb_list[o1])
{
struct fbm_file *m1, *m2;
m1 = (struct fbm_file *) (fb_list + o1);
m2 = (struct fbm_file *) (buf + o2);
if (o2 + m1->size + 2 >= list_size)
quit ("not enough space for file list");
memcpy ((char *) m2, (char *) m1, m1->size + 2);
m2->data_start = start;
start += (m1->data_size + 511) >> 9;
o1 += fb_list[o1] + 2;
o2 += buf[o2] + 2;
}
memset (buf + o2, 0, list_size - o2);
hd = open (argv[0], O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0666);
if (hd < 0)
quit ("can\'t write to file %s", argv[0]);
if (write (hd, buf, list_size) != list_size)
quit ("file write fails");
free (buf);
o1 = ((struct fb_data *) fb_list)->menu_ofs;
while (fb_list[o1])
{
struct fbm_file *m;
int n;
m = (struct fbm_file *) (fb_list + o1);
load_file_data (xd, m, hd);
n = m->data_size & 511;
if (n)
{
n = 512 - n;
memset (global_buffer, 0, n);
if (write (hd, global_buffer, n) != n)
quit ("file write fails");
}
o1 += fb_list[o1] + 2;
}
close (hd);
}
void
load_archive (xd_t *xd, int argc, char **argv)
{
uchar *buf;
int hd, ofs;
if (argc < 1)
quit ("not enough parameters");
hd = open (argv[0], O_RDONLY | O_BINARY);
if (hd < 0)
quit ("can\'t open file %s", argv[0]);
buf = get_ar_header (hd, 0);
ofs = sizeof (struct fb_ar_data);
while (buf[ofs])
{
struct fbm_file *m1, *m2;
uchar4 start;
int n;
m1 = (struct fbm_file *) (buf + ofs);
m2 = alloc_file (m1->name, &start, m1->data_size,
m1->flag & FBF_FLAG_EXTENDED, m1->data_time);
save_file_data (xd, m2, hd);
m2->flag = m1->flag;
if (m1->flag & FBF_FLAG_SYSLINUX)
syslinux_patch (xd, m2);
n = m1->data_size & 511;
if (n)
{
n = 512 - n;
if (read (hd, global_buffer, n) != n)
quit ("file read fails");
}
ofs += buf[ofs] + 2;
}
free (buf);
close (hd);
}
int
main (int argc, char **argv)
{
int i;
xd_t* xd;
assert (sizeof (time_t) == 4);
assert (sizeof (struct fb_mbr) == 512);
assert (sizeof (struct fat_bs16) == 512);
assert (sizeof (struct fat_bs32) == 512);
for (i = 1; i < argc; i++)
{
if (argv[i][0] != '-')
break;
if (! strcmp (argv[i], "--help") ||
! strcmp (argv[i], "-h"))
{
help ();
return 1;
}
else if (! strcmp (argv[i], "--version") ||
! strcmp (argv[i], "-V"))
{
fprintf (stderr, "%s version : %s build %d\n", progname, VERSION,
BUILD_NUMBER);
return 1;
}
else if (! strcmp (argv[i], "--verbose") ||
! strcmp (argv[i], "-v"))
{
verbosity++;
}
else if (! strcmp (argv[i], "--list") ||
! strcmp (argv[i], "-l"))
{
list_devs ();
return 0;
}
else if (! strcmp (argv[i], "--debug") ||
! strcmp (argv[i], "-d"))
{
fb_mbr_data = fb_mbr_dbg;
}
else
quit ("invalid option %s", argv[i]);
}
if (i >= argc - 1)
quit ("no device name or command");
xd = xd_open (argv[i], 1);
if (! xd)
quit ("open %s fails", argv[i]);
i++;
if (! strcmp (argv[i], "format"))
{
format_disk (xd, argc - i - 1, argv + i + 1);
}
else if (! strcmp (argv[i], "restore"))
{
restore_disk (xd);
}
else if (! strcmp (argv[i], "update"))
{
read_header (xd, 0);
update_header (xd);
write_header (xd);
}
else if (! strcmp (argv[i], "sync"))
{
read_header (xd, 0);
sync_disk (xd, argc - i - 1, argv + i + 1);
}
else if (! strcmp (argv[i], "info"))
{
read_header (xd, 1);
print_info ();
}
else if (! strcmp (argv[i], "clear"))
{
read_header (xd, 1);
clear_menu ();
write_header (xd);
}
else if (! strcmp (argv[i], "add"))
{
read_header (xd, 1);
add_file (xd, argc - i - 1, argv + i + 1);
write_header (xd);
}
else if (! strcmp (argv[i], "add-menu"))
{
read_header (xd, 1);
add_menu (xd, argc - i - 1, argv + i + 1);
write_header (xd);
}
else if (! strcmp (argv[i], "resize"))
{
read_header (xd, 1);
resize_file (xd, argc - i - 1, argv + i + 1);
write_header (xd);
}
else if (! strcmp (argv[i], "copy"))
{
read_header (xd, 1);
copy_file (xd, argc - i - 1, argv + i + 1);
write_header (xd);
}
else if (! strcmp (argv[i], "move"))
{
read_header (xd, 1);
move_file (xd, argc - i - 1, argv + i + 1);
write_header (xd);
}
else if (! strcmp (argv[i], "export"))
{
read_header (xd, 1);
export_file (xd, argc - i - 1, argv + i + 1);
}
else if (! strcmp (argv[i], "remove"))
{
read_header (xd, 1);
remove_file (xd, argc - i - 1, argv + i + 1);
write_header (xd);
}
else if (! strcmp (argv[i], "cat"))
{
read_header (xd, 1);
cat_file (xd, argc - i - 1, argv + i + 1);
}
else if (! strcmp (argv[i], "cat-menu"))
{
read_header (xd, 1);
cat_menu (xd, argc - i - 1, argv + i + 1);
}
else if (! strcmp (argv[i], "pack"))
{
read_header (xd, 1);
pack_disk (xd);
write_header (xd);
}
else if (! strcmp (argv[i], "check"))
{
read_header (xd, 0);
check_disk (xd);
}
else if (! strcmp (argv[i], "save"))
{
read_header (xd, 1);
save_archive (xd, argc - i - 1, argv + i + 1);
}
else if (! strcmp (argv[i], "load"))
{
read_header (xd, 1);
load_archive (xd, argc - i - 1, argv + i + 1);
write_header (xd);
}
else
quit ("Invalid command %s", argv[i]);
xd_close (xd);
return 0;
}
```
|
List of motorcycles in the National Motor Museum, Beaulieu in the U.K..
Notes
Motorcycle museums in the United Kingdom
Lists of motorcycles
Technology collections
|
The October 2010 North American storm complex is the name given to a historic extratropical cyclone that impacted North America. The massive storm complex caused a wide range of weather events including a major serial derecho stretching from the Gulf Coast to the Great Lakes, a widespread tornado outbreak across the Southeast United States and Midwest and a blizzard across portions of the Canadian Prairies and the Dakotas. The cyclone's lowest minimum pressure of made it the second most intense non-tropical system recorded in the continental United States (CONUS). The lowest confirmed pressure for a non-tropical system in the continental United States was set by a January 1913 Atlantic coast storm.
Meteorological synopsis
Significant snowfall was reported on the backside of the storm. The heaviest snow fell in parts of Minnesota where 9 inches (22.5 cm) of snow was reported in St. Louis County, Minnesota. Heavy snow and blizzard conditions also occurred in North Dakota, southwestern Manitoba and southeastern Saskatchewan.
The non-tropical cyclonic storm generated wind speeds of up to 70 mph, caused by a severe low pressure zone over Nebraska on October 24.
Akron, Cleveland, Findlay, Marion, Lorain, Mansfield, Toledo, Wooster and Youngstown, Ohio all witnessed heavy winds on the 24th.
Severe weather battered Illinois, Indiana, Michigan, and Ohio on the 25th and 26th of October, producing strong winds, rain, hail, and widespread tornadoes. It was the region's second strongest storm on record. The weather station in Bigfork, Minnesota, recorded a state record atmospheric pressure of 955.2 millibars (28.21 inches of pressure), typical of a Category 3 hurricane. The National Weather Service reported that a tornado with a maximum speed of 115 mph touched down about four miles east of Peotone in Will County, south of Chicago, that morning and traveled 2.9 miles, causing downed power lines and partially destroying a home. Another tornado was reported to have landed in Racine, Wisconsin.
Heavy damage was reported in the Chicago area, particularly in Kane, Will, Kankakee, and Iroquois Counties in Illinois and in Porter County in Indiana. The winds flipped single engine planes on their sides at DuPage Airport in West Chicago, and flights were delayed by 30 minutes at O'Hare and Midway airports. More than 300 flights were canceled at O'Hare International Airport, and more than 60,000 ComEd customers were without power. Several other less powerful tornadoes also occurred in Alabama, Arkansas, Kentucky, Michigan, North Carolina, Ohio, South Carolina, Tennessee, Texas, Virginia and Wisconsin. Heavy snow also fell in south western Ontario. There were no fatalities with this system. A GOES satellite image on October 26 showed what could be considered the eye of the storm over the Minnesota-Ontario border, with outlying clouds reaching as far as Alberta, southern Nunavut, Newfoundland, eastern Montana, Colorado, Louisiana, Maine and Bermuda.
The storm developed so quickly, that it was declared to be a weather 'bomb', which is an extremely fast developing storm that drops at least one millibar of pressure per hour for 24 hours—a phenomenon more commonly seen over water than land.
On the morning of October 26, a serial derecho caused widespread damage in Kentucky, Tennessee, Illinois, Wisconsin, Michigan and Ohio Tuesday. Louisville, Ky; Cincinnati, Cridersville, and Toledo, Ohio, Nashville, Tennessee Indianapolis were hit at 9 am CDT, and Detroit was hit during the midday and early afternoon hours. Other cities impacted by the storms included Pittsburgh, Pa., Buffalo, N.Y., and Charleston, W.Va. At one point in the morning a line of tornado warnings stretched from central Michigan down to northern Mississippi. Tornado damage to homes was also reported in and around Peotone, Ill., and Kokomo, Ind., while another tornado reportedly uprooted and downed trees onto homes near Racine, Wis.
On October 28, the storm system left the East Coast. During the next few days, the system moved eastward across the Atlantic, before stalling over the western Mediterranean on November 1. On November 5, the system dissipated over the western Mediterranean region.
Confirmed tornadoes
October 23 event
October 24 event
October 25 event
October 26 event
October 27 event
See also
Tornadoes of 2010
Cyclone Carmen
References
North American Storm Complex
Blizzards in the United States
10-23
Storm Complex
Articles containing video clips
Extratropical cyclones
Storm Complex
Storm Complex
Natural disasters in Minnesota
Natural disasters in North Carolina
Natural disasters in North Dakota
Natural disasters in Manitoba
Natural disasters in Saskatchewan
2010 disasters in Canada
|
```objective-c
// This is a part of the Active Template Library.
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#ifndef __ATL_HANDLER_IMPL__
#define __ATL_HANDLER_IMPL__
#pragma once
#if (NTDDI_VERSION < NTDDI_VISTA) // min Windows Vista required
#error Preview/Thumbnail/Search handlers are not supported on Windows versions prior to Vista.
#endif
#ifndef _ATL_NO_PRAGMA_WARNINGS
#pragma warning (push)
#endif //!_ATL_NO_PRAGMA_WARNINGS
#include <atldef.h>
#if !defined(_ATL_USE_WINAPI_FAMILY_DESKTOP_APP)
#error This file is not compatible with the current WINAPI_FAMILY
#endif
#include <Filterr.h>
#include <atlhandler.h>
#include <atlcoll.h>
#include <shobjidl.h>
#include <propsys.h>
#include <thumbcache.h>
#pragma pack(push,_ATL_PACKING)
namespace ATL
{
class ATL_NO_VTABLE CThumbnailProviderImpl :
public IInitializeWithStream,
public IThumbnailProvider
{
public:
CThumbnailProviderImpl() : m_pStream(NULL), m_pDocument(NULL)
{
}
virtual ~CThumbnailProviderImpl()
{
}
void FinalRelease()
{
ReleaseAll();
}
ATLPREFAST_SUPPRESS(6387 28196)
//IThumbnailProvider implementation
STDMETHOD (GetThumbnail)(
UINT cx,
__RPC__deref_out_opt HBITMAP *phbmp,
__RPC__out WTS_ALPHATYPE *pdwAlpha)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
if ((phbmp == NULL) || (pdwAlpha == NULL))
{
return E_POINTER;
}
*phbmp = NULL;
*pdwAlpha = WTSAT_UNKNOWN;
m_pDocument = CreateDocument();
if (m_pDocument == NULL)
{
return E_POINTER;
}
m_pDocument->AddRef();
HRESULT hr = LoadDocumentFromStream(m_pStream, m_grfMode);
if (FAILED(hr))
{
return hr;
}
hr = GetBitmap(cx, phbmp, pdwAlpha);
ReleaseAll();
return hr;
}
ATLPREFAST_UNSUPPRESS()
//IInitializeWithStream implementation
STDMETHOD (Initialize)(
_Inout_ IStream *pStream,
_In_ DWORD grfMode)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
// Initialize can be called more than once, so release existing valid m_pStream
if (m_pStream != NULL)
{
m_pStream->Release();
}
m_pStream = pStream;
m_pStream->AddRef();
m_grfMode = grfMode | STGM_SHARE_EXCLUSIVE;
return S_OK;
}
protected:
virtual IDocument* CreateDocument()
{
return NULL;
}
virtual HRESULT LoadDocumentFromStream(
_Inout_ IStream* pStream,
_In_ DWORD grfMode)
{
if (m_pDocument == NULL)
{
return E_POINTER;
}
return m_pDocument->LoadFromStream(pStream, grfMode);
}
virtual HRESULT GetBitmap(
_In_ UINT /* cx */,
_In_opt_ HBITMAP * /* phbmp */,
_In_opt_ WTS_ALPHATYPE * /* pdwAlpha */)
{
return E_NOTIMPL;
}
void ReleaseAll()
{
if (m_pStream != NULL)
{
m_pStream->Release();
m_pStream = NULL;
}
if (m_pDocument != NULL)
{
m_pDocument->Release();
m_pDocument = NULL;
}
}
protected:
IStream* m_pStream;
IDocument* m_pDocument;
DWORD m_grfMode;
};
template <class T>
class ATL_NO_VTABLE CPreviewHandlerImpl :
public IObjectWithSiteImpl<T>,
public IPreviewHandler,
public IOleWindow,
public IInitializeWithStream,
public IPreviewHandlerVisuals
{
public:
CPreviewHandlerImpl(void) :
m_pPreviewCtrl(NULL), m_pStream(NULL),
m_pFrame(NULL), m_hWndHost(NULL),
m_pDocument(NULL), m_clrBackColor(RGB(255, 255, 255)),
m_clrTextColor(0), m_pLogFont(NULL)
{
::SetRectEmpty(&m_rectHost);
}
virtual ~CPreviewHandlerImpl()
{
}
void FinalRelease()
{
ReleaseStream();
if (m_pPreviewCtrl != NULL)
{
m_pPreviewCtrl->Destroy();
m_pPreviewCtrl = NULL;
}
if (m_pFrame != NULL)
{
m_pFrame->Release();
m_pFrame = NULL;
}
if (m_pDocument != NULL)
{
m_pDocument->Release();
m_pDocument = NULL;
}
m_hWndHost = NULL;
SetRectEmpty(&m_rectHost);
}
//IPreviewHandler implementation
STDMETHOD (SetWindow)(
_In_ HWND hwnd,
_In_ const RECT *prc)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
m_hWndHost = hwnd;
CopyRect(&m_rectHost, prc);
if (m_pPreviewCtrl != NULL)
{
m_pPreviewCtrl->SetHost(hwnd);
m_pPreviewCtrl->SetRect(prc, FALSE);
}
return S_OK;
}
STDMETHOD (SetRect)(_In_ const RECT *prc)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
CopyRect(&m_rectHost, prc);
if (m_pPreviewCtrl != NULL)
{
m_pPreviewCtrl->SetRect(prc, TRUE);
}
return S_OK;
}
IFACEMETHODIMP DoPreview()
{
if (m_pPreviewCtrl == NULL)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
#ifdef AFX_PREVIEW_STANDALONE
m_pDocument = CreateDocument();
if (m_pDocument == NULL)
{
return E_FAIL;
}
m_pDocument->AddRef();
m_pPreviewCtrl = CreatePreviewControl();
if (m_pPreviewCtrl == NULL || !m_pPreviewCtrl->Create(m_hWndHost, &m_rectHost))
{
return E_FAIL;
}
m_pPreviewCtrl->SetDocument(m_pDocument);
#else
if (FAILED(InitializeDocumentPreview(m_hWndHost, &m_rectHost)))
{
return E_FAIL;
}
#endif
if (m_pPreviewCtrl != NULL)
{
m_pPreviewCtrl->SetPreviewVisuals(m_clrBackColor, m_clrTextColor, m_pLogFont);
}
// support for loading from archive
LoadDocumentFromStream(m_pStream);
// we can release stream now, otherwise the file remains locked for a long time
ReleaseStream();
}
if (m_pPreviewCtrl != NULL)
{
m_pPreviewCtrl->Redraw();
}
return S_OK;
}
IFACEMETHODIMP Unload()
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
ReleaseStream();
if (m_pPreviewCtrl != NULL)
{
m_pPreviewCtrl->Destroy();
m_pPreviewCtrl = NULL;
}
if (m_pDocument != NULL)
{
m_pDocument->Release();
m_pDocument = NULL;
}
if (m_pFrame != NULL)
{
m_pFrame->Release();
m_pFrame = NULL;
}
return S_OK;
}
IFACEMETHODIMP SetFocus()
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
HRESULT hr = S_FALSE;
if (m_pPreviewCtrl != NULL)
{
m_pPreviewCtrl->Focus();
hr = S_OK;
}
return hr;
}
STDMETHOD (QueryFocus)(_Out_ HWND *phwnd)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
HRESULT hr = S_OK;
*phwnd = ::GetFocus();
if (*phwnd == NULL)
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
return hr;
}
STDMETHOD (TranslateAccelerator)(_In_ MSG *pmsg)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
HRESULT hr = S_FALSE;
if (m_pFrame != NULL)
{
// If your previewer has multiple tab stops, you will need to do appropriate first/last child checking.
// This sample previewer has no tabstops, so we want to just forward this message out
hr = m_pFrame->TranslateAccelerator(pmsg);
}
return hr;
}
// IPreviewHandlerVisuals implementation
STDMETHOD (SetBackgroundColor)(_In_ COLORREF color)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
m_clrBackColor = color;
return S_OK;
}
STDMETHOD (SetFont)(_In_ const LOGFONTW *plf)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
m_pLogFont = (LOGFONTW*) plf;
return S_OK;
}
STDMETHOD (SetTextColor)(_In_ COLORREF color)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
m_clrTextColor = color;
return S_OK;
}
// IObjectWithSite override
STDMETHOD (SetSite)(_Inout_opt_ IUnknown *punkSite)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
__super::SetSite(punkSite);
// Clean up old frame
if (m_pFrame != NULL)
{
m_pFrame->Release();
m_pFrame = NULL;
}
// Get the new frame
if (m_spUnkSite)
{
m_spUnkSite->QueryInterface(&m_pFrame);
}
return S_OK;
}
// IOleWindow
STDMETHOD (GetWindow)(_Out_ HWND *phwnd)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
*phwnd = m_hWndHost;
return S_OK;
}
STDMETHOD (ContextSensitiveHelp)(_In_ BOOL)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
return E_NOTIMPL;
}
//IInitializeWithStream implementation
STDMETHOD (Initialize)(
_Inout_ IStream *pStream,
_In_ DWORD grfMode)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
// Initialize can be called more than once, so release existing valid m_pStream
ReleaseStream();
m_pStream = pStream;
m_pStream->AddRef();
m_grfMode = grfMode;
return S_OK;
}
protected:
virtual HRESULT InitializeDocumentPreview(
_In_ HWND /* hWnd */,
_In_opt_ RECT* /* prc */)
{
return E_NOTIMPL;
}
virtual IPreviewCtrl* CreatePreviewControl()
{
return NULL;
}
virtual IDocument* CreateDocument()
{
return NULL;
}
virtual HRESULT LoadDocumentFromStream(_Inout_ IStream* pStream)
{
if (m_pDocument == NULL)
{
return E_POINTER;
}
return m_pDocument->LoadFromStream(pStream, m_grfMode);
}
void ReleaseStream()
{
if (m_pStream != NULL)
{
m_pStream->Release();
m_pStream = NULL;
}
}
protected:
IPreviewCtrl* m_pPreviewCtrl;
IStream* m_pStream;
DWORD m_grfMode;
IPreviewHandlerFrame* m_pFrame;
HWND m_hWndHost;
RECT m_rectHost;
COLORREF m_clrBackColor;
COLORREF m_clrTextColor;
LOGFONTW* m_pLogFont;
IDocument* m_pDocument;
};
class ATL_NO_VTABLE CSearchFilterImpl :
public IPersistStream,
public IPersistFile,
public IFilter
{
public:
CSearchFilterImpl(void) :
m_pStream(NULL), m_pDocument(NULL),
m_dwChunkId(0), m_iText(0), m_pCurrentChunk(NULL)
{
m_hEventLog = NULL;
m_bEnableEventLog = FALSE;
}
virtual ~CSearchFilterImpl()
{
}
void FinalRelease()
{
ReleaseAll();
if (m_hEventLog != NULL)
{
CloseEventLog(m_hEventLog);
m_hEventLog = NULL;
}
}
public:
// IFilter implementation
SCODE STDMETHODCALLTYPE Init(
ULONG /* grfFlags */,
ULONG /* cAttributes */,
const FULLPROPSPEC * /* aAttributes */,
ULONG * /* pFlags */)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
HRESULT hr = S_OK;
if (m_hEventLog == NULL && m_bEnableEventLog)
{
m_hEventLog = OpenEventLog(NULL, L"Search Handler");
}
if (m_bEnableEventLog)
{
PCWSTR pszMsg = L"IFilter::Init entered.";
ReportEvent(m_hEventLog, EVENTLOG_SUCCESS, 0, 1, NULL, 1, 0, &pszMsg, NULL);
}
m_pDocument = CreateDocument();
if (m_pDocument == NULL)
{
return E_FAIL;
}
m_pDocument->AddRef();
hr = LoadDocumentFromStream(m_pStream, STGM_READ | STGM_SHARE_EXCLUSIVE);
if (FAILED(hr))
{
if (m_bEnableEventLog)
{
PCWSTR pszMsg = L"IFilter::Init (LoadDocumentFromStream) failed.";
ReportEvent(m_hEventLog, EVENTLOG_ERROR_TYPE, 0, 0, NULL, 1, sizeof (DWORD), &pszMsg, &hr);
}
return hr;
}
m_pDocument->InitializeSearchContent();
m_pDocument->BeginReadChunks();
return S_OK;
}
SCODE STDMETHODCALLTYPE GetChunk(STAT_CHUNK *pStat)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
HRESULT hr = S_OK;
try
{
// Get the chunk from the derived class. A return of S_FALSE indicates the
// chunk should be skipped and we should try to get the next chunk.
int cIterations = 0;
hr = S_FALSE;
while (S_FALSE == hr)
{
pStat->idChunk = m_dwChunkId;
hr = S_OK;
if (!m_pDocument->ReadNextChunkValue(&m_pCurrentChunk))
{
hr = FILTER_E_END_OF_CHUNKS;
}
++cIterations;
}
if (hr == S_OK)
{
if (m_pCurrentChunk != NULL && m_pCurrentChunk->IsValid())
{
// copy out the STAT_CHUNK
m_pCurrentChunk->CopyChunk(pStat);
// and set the id to be the sequential chunk
pStat->idChunk = ++m_dwChunkId;
}
else
{
hr = E_INVALIDARG;
}
}
}
catch (CAtlException e)
{
ATLTRACE2(atlTraceGeneral, 4, L"CMFCWSFilterImpl::GetChunk ATL exception! hr = 0x%x", e.m_hr);
hr = e.m_hr;
}
if (m_bEnableEventLog)
{
PCWSTR pszMsg = L"IFilter::GetChunk.";
ReportEvent(m_hEventLog, EVENTLOG_SUCCESS, 0, 2, NULL, 1, sizeof (DWORD), &pszMsg, &hr);
}
return hr;
}
SCODE STDMETHODCALLTYPE GetText(
ULONG *pcwcBuffer,
WCHAR *awcBuffer)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
HRESULT hr = S_OK;
if ((pcwcBuffer == NULL) || (*pcwcBuffer == 0))
{
return E_INVALIDARG;
}
if (m_pCurrentChunk == NULL || !m_pCurrentChunk->IsValid())
{
return FILTER_E_NO_MORE_TEXT;
}
if (m_pCurrentChunk->GetChunkType() != CHUNK_TEXT)
{
return FILTER_E_NO_TEXT;
}
try
{
int cchTotal = m_pCurrentChunk->GetString().GetLength();
int cchLeft = cchTotal - m_iText;
int cchToCopy = min((int)*pcwcBuffer - 1, cchLeft);
if (cchToCopy > 0)
{
PCWSTR psz = ((PCWSTR)m_pCurrentChunk->GetString()) + m_iText;
// copy the chars
wcsncpy_s(awcBuffer, *pcwcBuffer, psz, cchToCopy);
// null terminate it
awcBuffer[cchToCopy] = '\0';
// set how much data is copied
*pcwcBuffer = cchToCopy;
// remember we copied it
m_iText += cchToCopy;
cchLeft -= cchToCopy;
if (cchLeft == 0)
{
hr = FILTER_S_LAST_TEXT;
}
}
else
{
hr = FILTER_E_NO_MORE_TEXT;
}
}
catch (CAtlException e)
{
ATLTRACE2(atlTraceGeneral, 4, L"CMFCWSFilterImpl::GetText ATL exception! hr = 0x%x", e.m_hr);
hr = e.m_hr;
}
if (m_bEnableEventLog)
{
PCWSTR pszMsg = L"IFilter::GetText.";
ReportEvent(m_hEventLog, EVENTLOG_SUCCESS, 0, 3, NULL, 1, sizeof(DWORD), &pszMsg, &hr);
}
return hr;
}
SCODE STDMETHODCALLTYPE GetValue(PROPVARIANT **ppPropValue)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
HRESULT hr = S_OK;
// if this is not a value chunk they shouldn't be calling this
if (m_pCurrentChunk == NULL || m_pCurrentChunk->GetChunkType() != CHUNK_VALUE)
{
return FILTER_E_NO_MORE_VALUES;
}
try
{
if (m_pCurrentChunk->IsValid())
{
// return the value of this chunk as a PROPVARIANT ( they own freeing it properly )
hr = m_pCurrentChunk->GetValue(ppPropValue);
m_pCurrentChunk->Clear();
}
else
{
// we have already return the value for this chunk, go away
hr = FILTER_E_NO_MORE_VALUES;
}
}
catch (CAtlException e)
{
ATLTRACE2(atlTraceGeneral, 4, L"CMFCWSFilterImpl::GetValue ATL exception! hr = 0x%x", e.m_hr);
hr = e.m_hr;
}
if (m_bEnableEventLog)
{
PCWSTR pszMsg = L"IFilter::GetValue.";
ReportEvent(m_hEventLog, EVENTLOG_SUCCESS, 0, 4, NULL, 1, sizeof(DWORD), &pszMsg, &hr);
}
return hr;
}
SCODE STDMETHODCALLTYPE BindRegion(
FILTERREGION /* origPos */,
REFIID /* riid */,
void ** /* ppunk */)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
ATLTRACE2(atlTraceGeneral, 4, L"BindRegion: not implemented");
return E_NOTIMPL;
}
// IPersistStream implementation
// IPersistStream::Load() is used by WS 3.x and above for the index
// search case when this filter is loaded into the filter host process
STDMETHODIMP Load(__RPC__in_opt IStream *pStream)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
if (m_hEventLog == NULL)
{
m_hEventLog = OpenEventLog(NULL, L"Search Handler");
}
if (pStream == NULL)
{
return E_FAIL;
}
// Initialize can be called more than once, so release existing valid m_pStream
if (m_pStream != NULL)
{
m_pStream->Release();
}
m_pStream = pStream;
m_pStream->AddRef();
if (m_bEnableEventLog)
{
PCWSTR pszMsg = L"IPersistStream::Load entered.";
ReportEvent(m_hEventLog, EVENTLOG_SUCCESS, 0, 0, NULL, 1, 0, &pszMsg, NULL);
}
return S_OK;
};
STDMETHODIMP Save(
__RPC__in_opt IStream * /* pStm */,
BOOL /* fClearDirty */)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
return E_NOTIMPL;
};
STDMETHODIMP GetSizeMax(_Out_ ULARGE_INTEGER * /* pcbSize */)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
return E_NOTIMPL;
};
STDMETHODIMP IsDirty()
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
return S_FALSE;
}
STDMETHODIMP GetClassID(_In_opt_ CLSID * /* pClassID */)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
ATLTRACE2(atlTraceGeneral, 4, L"GetClassID: must be implemented in a derived class.");
return E_NOTIMPL;
}
// IPersistFile implementation
STDMETHODIMP Load(
_In_z_ LPCWSTR pszFileName,
_In_ DWORD dwMode)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
HRESULT hr = SHCreateStreamOnFileEx(pszFileName, dwMode, 0, FALSE, NULL, &m_pStream);
return hr;
};
// these methods are never called by WS
STDMETHODIMP Save(
_In_opt_z_ LPCWSTR /* pszFileName */,
_In_ BOOL /* fRemember */)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
return E_NOTIMPL;
};
STDMETHODIMP SaveCompleted(
_In_opt_z_ LPCWSTR /* pszFileName */)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
return E_NOTIMPL;
};
STDMETHODIMP GetCurFile(
_In_opt_ LPWSTR* /* pszFileName */)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
return E_NOTIMPL;
};
protected:
virtual IDocument* CreateDocument()
{
return NULL;
}
virtual HRESULT LoadDocumentFromStream(
_Inout_ IStream* pStream,
_In_ DWORD grfMode)
{
if (m_pDocument == NULL)
{
return E_POINTER;
}
return m_pDocument->LoadFromStream(pStream, grfMode);
}
void ReleaseAll()
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
if (m_pStream != NULL)
{
m_pStream->Release();
m_pStream = NULL;
}
if (m_pDocument != NULL)
{
m_pDocument->Release();
m_pDocument = NULL;
}
}
protected:
IStream* m_pStream;
IDocument* m_pDocument;
IFilterChunkValue* m_pCurrentChunk; // the current chunk value
DWORD m_dwChunkId; // Current chunk id
DWORD m_iText; // index into ChunkValue
HANDLE m_hEventLog;
BOOL m_bEnableEventLog;
};
class CFilterChunkValueImpl :
public IFilterChunkValue
{
public:
CFilterChunkValueImpl()
{
Clear();
}
~CFilterChunkValueImpl()
{
Clear();
}
virtual void Clear()
{
m_fIsValid = false;
ZeroMemory(&m_chunk, sizeof(m_chunk));
PropVariantInit(&m_propVariant);
m_strValue.Empty();
}
virtual BOOL IsValid() const
{
return m_fIsValid;
}
ATLPREFAST_SUPPRESS(6387)
virtual HRESULT GetValue(_Outptr_ PROPVARIANT **ppPropVariant)
{
HRESULT hr = S_OK;
*ppPropVariant = NULL;
CComHeapPtr<PROPVARIANT> spPropVariant;
// allocate a propvariant on the COM heap
if (spPropVariant.Allocate())
{
// fill it with COMHeap copied data from our local non-com heap propvariant
hr = PropVariantCopy(spPropVariant, &m_propVariant);
}
else
{
hr = E_OUTOFMEMORY;
}
if (SUCCEEDED(hr))
{
// detach and return this as the value
*ppPropVariant = spPropVariant.Detach();
}
return hr;
}
ATLPREFAST_UNSUPPRESS()
virtual PROPVARIANT GetValueNoAlloc()
{
return m_propVariant;
}
virtual CString& GetString()
{
return m_strValue;
}
virtual HRESULT CopyChunk(_Out_ STAT_CHUNK *pStatChunk)
{
*pStatChunk = m_chunk;
return S_OK;
}
virtual CHUNKSTATE GetChunkType() const
{
return m_chunk.flags;
}
virtual REFGUID GetChunkGUID() const
{
return m_chunk.attribute.guidPropSet;
}
virtual DWORD GetChunkPID() const
{
return m_chunk.attribute.psProperty.propid;
}
// set the property by key to a unicode string
virtual HRESULT SetTextValue(
_In_ REFPROPERTYKEY pkey,
_In_z_ LPCTSTR pszValue,
_In_ CHUNKSTATE chunkType = CHUNK_VALUE,
_In_ LCID locale = 0,
_In_ DWORD cwcLenSource = 0,
_In_ DWORD cwcStartSource = 0,
_In_ CHUNK_BREAKTYPE chunkBreakType = CHUNK_NO_BREAK)
{
HRESULT hr = SetChunk(pkey, chunkType, locale, cwcLenSource, cwcStartSource, chunkBreakType);
if (SUCCEEDED(hr))
{
m_strValue = pszValue;
m_propVariant.vt = VT_LPWSTR;
m_propVariant.pwszVal = (LPWSTR)(LPCWSTR)m_strValue;
m_fIsValid = true;
}
return hr;
}
// set the property by key to a bool
virtual HRESULT SetBoolValue(
_In_ REFPROPERTYKEY pkey,
_In_ BOOL bVal,
_In_ CHUNKSTATE chunkType = CHUNK_VALUE,
_In_ LCID locale = 0,
_In_ DWORD cwcLenSource = 0,
_In_ DWORD cwcStartSource = 0,
_In_ CHUNK_BREAKTYPE chunkBreakType = CHUNK_NO_BREAK)
{
return SetBoolValue(pkey, bVal ? VARIANT_TRUE : VARIANT_FALSE, chunkType, locale, cwcLenSource, cwcStartSource, chunkBreakType);
}
// set the property by key to a variant bool
virtual HRESULT SetBoolValue(
_In_ REFPROPERTYKEY pkey,
_In_ VARIANT_BOOL bVal,
_In_ CHUNKSTATE chunkType = CHUNK_VALUE,
_In_ LCID locale = 0,
_In_ DWORD cwcLenSource = 0,
_In_ DWORD cwcStartSource = 0,
_In_ CHUNK_BREAKTYPE chunkBreakType = CHUNK_NO_BREAK)
{
HRESULT hr = SetChunk(pkey, chunkType, locale, cwcLenSource, cwcStartSource, chunkBreakType);
if (SUCCEEDED(hr))
{
m_propVariant.vt = VT_BOOL;
m_propVariant.boolVal = bVal;
m_fIsValid = true;
}
return hr;
}
// set the property by key to an int
virtual HRESULT SetIntValue(
_In_ REFPROPERTYKEY pkey,
_In_ int nVal,
_In_ CHUNKSTATE chunkType = CHUNK_VALUE,
_In_ LCID locale = 0,
_In_ DWORD cwcLenSource = 0,
_In_ DWORD cwcStartSource = 0,
_In_ CHUNK_BREAKTYPE chunkBreakType = CHUNK_NO_BREAK)
{
HRESULT hr = SetChunk(pkey, chunkType, locale, cwcLenSource, cwcStartSource, chunkBreakType);
if (SUCCEEDED(hr))
{
m_propVariant.vt = VT_I4;
m_propVariant.lVal = nVal;
m_fIsValid = true;
}
return hr;
}
// set the property by key to a long
virtual HRESULT SetLongValue(
_In_ REFPROPERTYKEY pkey,
_In_ long lVal,
_In_ CHUNKSTATE chunkType = CHUNK_VALUE,
_In_ LCID locale = 0,
_In_ DWORD cwcLenSource = 0,
_In_ DWORD cwcStartSource = 0,
_In_ CHUNK_BREAKTYPE chunkBreakType = CHUNK_NO_BREAK)
{
HRESULT hr = SetChunk(pkey, chunkType, locale, cwcLenSource, cwcStartSource, chunkBreakType);
if (SUCCEEDED(hr))
{
m_propVariant.vt = VT_I4;
m_propVariant.lVal = lVal;
m_fIsValid = true;
}
return hr;
}
// set the property by key to a dword
virtual HRESULT SetDwordValue(
_In_ REFPROPERTYKEY pkey,
_In_ DWORD dwVal,
_In_ CHUNKSTATE chunkType = CHUNK_VALUE,
_In_ LCID locale = 0,
_In_ DWORD cwcLenSource = 0,
_In_ DWORD cwcStartSource = 0,
_In_ CHUNK_BREAKTYPE chunkBreakType = CHUNK_NO_BREAK)
{
HRESULT hr = SetChunk(pkey, chunkType, locale, cwcLenSource, cwcStartSource, chunkBreakType);
if (SUCCEEDED(hr))
{
m_propVariant.vt = VT_UI4;
m_propVariant.ulVal = dwVal;
m_fIsValid = true;
}
return hr;
}
// set property by key to an int64
virtual HRESULT SetInt64Value(
_In_ REFPROPERTYKEY pkey,
_In_ __int64 nVal,
_In_ CHUNKSTATE chunkType = CHUNK_VALUE,
_In_ LCID locale = 0,
_In_ DWORD cwcLenSource = 0,
_In_ DWORD cwcStartSource = 0,
_In_ CHUNK_BREAKTYPE chunkBreakType = CHUNK_NO_BREAK)
{
HRESULT hr = SetChunk(pkey, chunkType, locale, cwcLenSource, cwcStartSource, chunkBreakType);
if (SUCCEEDED(hr))
{
m_propVariant.vt = VT_I8;
m_propVariant.hVal.QuadPart = nVal;
m_fIsValid = true;
}
return hr;
}
// set property by key to a SystemTime
virtual HRESULT SetSystemTimeValue(
_In_ REFPROPERTYKEY pkey,
_In_ const SYSTEMTIME &systemTime,
_In_ CHUNKSTATE chunkType = CHUNK_VALUE,
_In_ LCID locale = 0,
_In_ DWORD cwcLenSource = 0,
_In_ DWORD cwcStartSource = 0,
_In_ CHUNK_BREAKTYPE chunkBreakType = CHUNK_NO_BREAK)
{
HRESULT hr = SetChunk(pkey, chunkType, locale, cwcLenSource, cwcStartSource, chunkBreakType);
if (SUCCEEDED(hr))
{
m_propVariant.vt = VT_FILETIME;
SystemTimeToFileTime(&systemTime, &m_propVariant.filetime);
m_fIsValid = true;
}
return hr;
}
// set Property by key to a filetime
virtual HRESULT SetFileTimeValue(
_In_ REFPROPERTYKEY pkey,
_In_ FILETIME dtVal,
_In_ CHUNKSTATE chunkType = CHUNK_VALUE,
_In_ LCID locale = 0,
_In_ DWORD cwcLenSource = 0,
_In_ DWORD cwcStartSource = 0,
_In_ CHUNK_BREAKTYPE chunkBreakType = CHUNK_NO_BREAK)
{
HRESULT hr = SetChunk(pkey, chunkType, locale, cwcLenSource, cwcStartSource, chunkBreakType);
if (SUCCEEDED(hr))
{
m_propVariant.vt = VT_FILETIME;
m_propVariant.filetime = dtVal;
m_fIsValid = true;
}
return hr;
}
virtual void CopyFrom(_Inout_ IFilterChunkValue* pValue)
{
Clear();
pValue->CopyChunk (&m_chunk);
// NOTE this object does not contain a real property variant that was allocated with CoTaskMemAlloc
m_propVariant = pValue->GetValueNoAlloc ();
m_strValue = pValue->GetString ();
// fix up the string ownership to member
if (m_propVariant.vt == VT_LPWSTR)
{
m_propVariant.pwszVal = (LPWSTR)(LPCWSTR)m_strValue;
}
else if (m_propVariant.vt & VT_VECTOR)
{
}
m_fIsValid = pValue->IsValid();
return;
}
protected:
// set the locale for this chunk
HRESULT SetChunk(
_In_ REFPROPERTYKEY pkey,
_In_ CHUNKSTATE chunkType = CHUNK_VALUE,
_In_ LCID locale = 0,
_In_ DWORD cwcLenSource = 0,
_In_ DWORD cwcStartSource = 0,
_In_ CHUNK_BREAKTYPE chunkBreakType = CHUNK_NO_BREAK)
{
Clear();
// initialize the chunk
m_chunk.attribute.psProperty.ulKind = PRSPEC_PROPID;
m_chunk.attribute.psProperty.propid = pkey.pid;
m_chunk.attribute.guidPropSet = pkey.fmtid;
m_chunk.flags = chunkType;
m_chunk.locale = locale == 0 ? GetUserDefaultLCID() : locale;
m_chunk.cwcLenSource = cwcLenSource;
m_chunk.cwcStartSource = cwcStartSource;
m_chunk.breakType = chunkBreakType;
return S_OK;
}
// member variables
private:
BOOL m_fIsValid;
STAT_CHUNK m_chunk;
PROPVARIANT m_propVariant;
CString m_strValue;
};
class CAtlDocumentImpl :
public IDocument
{
public:
virtual void BeginReadChunks()
{
m_posReadChunk = m_lstChunks.GetHeadPosition();
}
virtual void ClearChunkList()
{
m_posReadChunk = NULL;
POSITION pos = m_lstChunks.GetHeadPosition();
while (pos != NULL)
{
IFilterChunkValue* v = (IFilterChunkValue*) m_lstChunks.GetNext(pos);
if (v != NULL)
{
delete v;
}
}
m_lstChunks.RemoveAll();
}
virtual BOOL SetChunkValue(_Inout_ IFilterChunkValue* pValue)
{
if (pValue == NULL || !pValue->IsValid())
{
return false;
}
POSITION pos = FindChunk(pValue->GetChunkGUID(), pValue->GetChunkPID());
if (pos == NULL)
{
m_lstChunks.AddTail(pValue);
}
return TRUE;
}
virtual _Success_(return != FALSE) BOOL ReadNextChunkValue(_Outptr_ IFilterChunkValue** ppValue)
{
if (m_posReadChunk == NULL || ppValue == NULL)
{
return FALSE;
}
*ppValue = (IFilterChunkValue*) m_lstChunks.GetNext(m_posReadChunk);
return TRUE;
}
virtual void RemoveChunk(
_In_ REFCLSID guid,
_In_ DWORD pid)
{
POSITION pos = FindChunk(guid, pid);
if (pos != NULL)
{
delete m_lstChunks.GetAt(pos);
m_lstChunks.RemoveAt(pos);
}
}
virtual POSITION FindChunk(
_In_ REFCLSID guid,
_In_ DWORD pid)
{
POSITION value = NULL;
POSITION pos = m_lstChunks.GetHeadPosition();
POSITION posPrev = NULL;
while (pos != NULL)
{
posPrev = pos;
IFilterChunkValue* v = (IFilterChunkValue*) m_lstChunks.GetNext(pos);
if (IsEqualIID(v->GetChunkGUID(), guid) && v->GetChunkPID() == pid)
{
value = posPrev;
break;
}
}
return value;
}
ATLPREFAST_SUPPRESS(6101)
_Success_(return != FALSE) BOOL GetThumbnail(
_In_ UINT cx,
_Out_ HBITMAP* phbmp,
_Out_ WTS_ALPHATYPE* /* pdwAlpha */)
{
HDC hdc = ::GetDC(NULL);
RECT rcBounds;
SetRect(&rcBounds, 0, 0, cx, cx);
HDC hDrawDC = CreateCompatibleDC(hdc);
if (hDrawDC == NULL)
{
ReleaseDC(NULL, hdc);
return FALSE;
}
HBITMAP hBmp = CreateCompatibleBitmap(hDrawDC, cx, cx);
if (hBmp == NULL)
{
ReleaseDC(NULL, hdc);
DeleteDC(hDrawDC);
return FALSE;
}
HBITMAP hOldBitmap = (HBITMAP) SelectObject(hDrawDC, hBmp);
// Here you need to draw the document's data
OnDrawThumbnail(hDrawDC, &rcBounds);
SelectObject(hDrawDC, hOldBitmap);
DeleteDC(hDrawDC);
ReleaseDC(NULL, hdc);
*phbmp = hBmp;
return TRUE;
}
ATLPREFAST_UNSUPPRESS()
virtual void OnDrawThumbnail(
_In_ HDC /* hDrawDC */,
_In_ LPRECT /* lprcBounds */)
{
}
virtual LPVOID GetContainer() const
{
return (LPVOID) this;
}
protected:
CAtlList<IFilterChunkValue*> m_lstChunks;
POSITION m_posReadChunk;
};
} //namespace ATL
#pragma pack(pop)
#ifndef _ATL_NO_PRAGMA_WARNINGS
#pragma warning (pop)
#endif //!_ATL_NO_PRAGMA_WARNINGS
#endif // __ATL_HANDLER_IMPL__
```
|
The amethyst-throated sunangel (Heliangelus amethysticollis) is a species of hummingbird in the "coquettes", tribe Lesbiini of subfamily Lesbiinae. It is found in Bolivia, Ecuador, and Peru.
Taxonomy and systematics
The amethyst-throated sunangel's taxonomy is not settled. The International Ornithological Committee (IOC), BirdLife International's Handbook of the Birds of the World (HBW), and the Clements taxonomy assign these four subspecies to it:
H. a. laticlavius, Salvin (1891)
H. a. decolor, Zimmer, JT (1951)
H. a. apurimacensis, Weller (2009)
H. a. amethysticollis, d'Orbigny & Lafresnaye (1838)
The South American Classification Committee (SACC) of the American Ornithological Society includes three other subspecies. They are H. a. violiceps and H. a. clarisse that IOC, HBW, and the Clements taxonomy treat as Longuemare's sunangel (H. clarisse) and H. a. spencei that they treat as the Mérida sunangel (H. spencei).
Description
The amethyst-throated sunangel, as defined by the IOC, is about long and weighs . The species has a straight, rather short, black bill. The adult male of nominate subspecies H. a. amethysticollis has shiny dark green upperparts with a bright green frontlet just above the bill. Its throat and upper breast gorget is rosy amethyst. That area has a narrow black border on the neck and a broader cinnamon band below it. The lower breast is glittery green and the rest of the underparts buff with green discs. The central tail feathers are bronze-green and the outer ones blue-black. The adult female is similar to the male but has a rusty throat with black flecks. Immatures are similar to the female.
Subspecies H. a. laticlavius has a reddish purple gorget, a whitish breastband, and a buffy grayish belly. H. a. decolor has a paler frontlet than the nominate; its gorget is a deeper violet, its breast band whiter, and its belly grayer. H. a. apurimacensis has a turquoise-green frontlet, a whitish buff breast, and a pale buff belly.
Distribution and habitat
The four subspecies of amethyst-throated sunangel are found thus:
H. a. laticlavius, the Andes of southern Ecuador south to northern Department of Cajamarca in Peru
H. a. decolor, the eastern slope of the Andes in central Peru from south of the Marañón River to the Department of Junín
H. a. apurimacensis, the valleys of the Apurímac River and upper Urubamba River in the departments of Ayacucho and Cusco, southeastern Peru
H. a. amethysticollis, the eastern slope of the Andes from southern Peru into northwestern Bolivia as far as Cochabamba Department
The species inhabits wet and humid montane forest including cloudforest and elfin forest. Though it is found at forest edges and open bushy terrain, it prefers the interior of closed forest. In elevation it mostly ranges between but has been often recorded as high as in Peru.
Behavior
Movement
The amethyst-throated sunangel is sedentary.
Feeding
The amethyst-throated sunangel feeds on nectar and also includes a high percentage of insects in its diet. It defends feeding territories that are dense with nectar sources; with its short bill it primarily feeds at flowers with shallow corollas. It typically feeds at heights up to and always near cover at the forest edge or interior. It captures insects by hawking from a perch.
Breeding
The amethyst-throated sunangel nests in Peru during February and March. It builds a nest of fine plant fiber, moss, and lichens attached to a strand of moss dangling from a branch. It typically places it about above ground and under a leaf or clump of moss that shelters it from weather. The clutch of two eggs is incubated by the female, who first breeds in her second year. The incubation period and time to fledging are not known.
Vocalization
The amethyst-throated sunangel's call is "a short, buzzy, dry trill...repeated at intervals."
Status
The IUCN has assessed the amethyst-throated sunangel as being of Least Concern. Its population size is not known but is believed to be stable. It is fairly common overall, locally abundant, and occurs in several protected areas.
References
amethyst-throated sunangel
Birds of the Ecuadorian Andes
Birds of the Peruvian Andes
Birds of the Bolivian Andes
amethyst-throated sunangel
Taxonomy articles created by Polbot
|
CNCI usually refers to either:
The Chittaranjan National Cancer Institute
The Comprehensive National Cybersecurity Initiative
|
Remte is a Latvian village, located in Saldus Municipality, Remte Parish. Located in the middle of the parish on the shores of Remte Lake and P109 national road. 17.5 km from Municipality center Saldus and 107 km from nation capital Riga. In Remte there is a parish administration, library, culture house, primary school, church, doctor's internist's practice, social care center "Atpūtas", post office, shop. Village has formed around the Remte Manor (Remten) center. After the Second World War, village grew around the Soviet Kolkhoz "Remte". The buildings of Remte Manor, the park and the Remte Lutheran Church are monuments of national significance.
References
Villages in Latvia
Saldus Municipality
|
Nikitaras () was the nom de guerre of Nikitas Stamatelopoulos () (c. 17841849), a Greek revolutionary in the Greek War of Independence. Due to his fighting prowess, he was known as Turkofagos or Turkophagos (), literally meaning the "Turk-Eater".
Biography
The date and place of Nikitaras' birth are disputed, but he is thought to have been born either in the village of Nedoussa (Νέδουσα) in the Peloponnesian province of Messenia or in Leontari in Arcadia circa 1784. He was a nephew of Theodoros Kolokotronis, the most important Greek military leader of the Revolution. Turkish authorities tried to capture him, as well as Kolokotronis, but he escaped and joined his uncle in the British-held Ionian Islands.
When the Greek war of Independence began, both returned to the mainland. He was with Kolokotronis, who commanded the Greek army at the Siege of Tripoli early in the war. When the commander and his men tried to escape the city, Nikitaras and his troops cut off the escape of the Turkish commander and his troops and slaughtered them. Nikitas achieved fame and his sobriquet "Turk-Eater" in the Battle of Dervenakia, where he is said to have used five swords: four broke from excessive use. During the civil war within the Revolution, he sided with his uncle against the faction around Alexander Mavrokordatos.
Nikitaras was a strong patriot, not corrupt like many of the leaders of the Revolution. When Ioannis Kolettis asked him to kill a rival, Odysseas Androutsos, in exchange for a government position, Nikitaras refused the offer and became angry with Kolettis. He also refused to take booty after battle, a normal practice of Balkan irregulars at the time. After the Revolution he and his family were living in poverty.
After the war, Nikitaras was jailed with his uncle Kolokotronis as strong opponents of the Bavarian Regency. He was also a strong campaigner for the rights of those who fought in the Revolution. Nikitaras was released from prison in 1841, but the period in jail broke his health and he died in 1849 in Piraeus.
Legacy
He is especially famous for his words during the Third Siege of Missolonghi. When he arrived in the city with supplies, soldiers, who had not been paid in months, asked him if he had brought any money. Nikitaras, angry, flung down his sword, a weapon taken from a Turk he had killed, uttering the words: "I have only my sword, and that I gladly give for my country."
Nikitaras is remembered in the poem by Nikos Gatsos, "The Knight and Death".
References
Citations
Bibliography
1780s births
1849 deaths
18th-century Greek people
19th-century Greek people
Greek people of the Greek War of Independence
Speakers of the Hellenic Parliament
Members of the Greek Senate
People from Arcadia, Peloponnese
People from Kalamata
|
Alenka Gotar is a Slovene soprano singer, born in Rodica in 1977. With the song "Cvet z juga" ("Flower of the South"), she represented Slovenia in the Eurovision Song Contest 2007 in Helsinki, Finland. Achieving seventh place in the semi-final, she became the first Slovene to qualify to the grand final, where she ended fifteenth with 66 points.
Biography
Alenka Gotar began her musical interest by attending a small music school where she learned piano and guitar. Afterwards, she attended music and ballet school in Ljubljana, where Markos Bajuk taught her solo singing. After graduating in 1996, she applied to study singing at the Musical Academy in Basel, Switzerland, and in 1999, she attended the Universität Mozarteum Salzburg, where she was taught by Lilijan Sukis. Alenka gained her diploma in 2000. In Salzburg, she continued studies in singing and opera with Sukis, along with perfecting her craft in Rome with Maya Sunari-Biankini, and with Marjana Lipovšek and Alfred Burgstaller. She gained her master's degree in 2006.
Alenka Gotar is a guest in the Maribor Opera and as a soloist, she sings in the state theatres in Salzburg and Ljubljana. She toured with an orchestra and chamber choir in Slovenia, Austria, Switzerland, Germany, Croatia, and Scandinavia. Her repertoire ranges from baroque to modern musical pieces. She also works as music teacher.
On 4 February 2007, Alenka Gotar won EMA 2007, the Slovenian national selection for Eurovision 2007. In Helsinki, during the semi-final on 10 May 2007, Alenka sang "Cvet z juga" and progressed to the finals, where she placed 15th with the same song. The song, described as a fast rhythmic ballad combined with operatic vocals, was written and composed by Andrej Babić and arranged by Aleksandra Valenčić. EMA 2007 was the edition of the competition to decide the winner completely by televoting. After two semi-finals and a final, the Slovenian public had a choice between Alenka and Eva Černe. With 44,636 votes, Alenka was crowned the winner and given the right to represent Slovenia at Eurovision.
During the 2018 Slovenian parliamentary election, Alenka Gotar stood as a parliamentary candidate for the Slovenian Democratic Party but, ultimately, did not gain a seat in the Slovenian National Assembly despite her party's victory in the election.
Opera Roles
From the summer of 2000, Alenka Gotar has been a frequent guest in the SNG opera and ballet in Ljubljana, where she has sung in the following roles:
Barbarina (The Marriage of Figaro – Mozart);
Donna Elvira (Don Giovanni – Mozart);
Rusalka (Rusalka – Dvořák);
Hanna Glawary (The Merry Widow – Lehár);
Pamina (The Magic Flute – Mozart/Schikaneder)
Gran Sacerdotessa (Aida – Verdi).
In the 2004–2005 season, she performed the following roles:
Brigitte (Iolanta – Tchaikovsky);
Bubikopf (The Emperor of Atlantis – Ullmann)
Kristine (Brata – Alojz Ajdič)
In Salzburg she performed the following roles:
Susanna (The Marriage of Figaro – Mozart);
Pamina (The Magic Flute – Mozart);
Arminda (La finta giardiniera – Mozart);
Hyazintus (Apollo et Hyacinthus – Mozart)
Mimi (La bohème – Puccini).
In the festival Europäische Musikmonat 2001 in Basel, she sang the soprano role in the opera Skamander, by the Swiss composer Beato Gysin. In 2000, Alenka worked with the well known composer György Kurtag for the Swiss radio DRC3.
Songs
Cvet z juga (Flower of the South) (2007)
"Ženska iz soli" (Woman Made Of Salt) (2007)
"Odidi" (Leave) (2008)
"Nek Te Voli Kao Ja" (No One Loves You Like I Do) (2008)
"Mostovi" (Bridges) Ft. Sons (2008)
"Samo Ti" (Only You) Ft. Oliver Dragojević (2009)
See also
Slovenia in the Eurovision Song Contest 2007
References
External links
Alenka Gotar – Official Website
Winning song from EMA 2007 – RTV SLO
1977 births
Living people
Musicians from Ljubljana
21st-century Slovenian women singers
Slovenian operatic sopranos
Eurovision Song Contest entrants for Slovenia
Eurovision Song Contest entrants of 2007
People from the Municipality of Domžale
21st-century women opera singers
|
```objective-c
/* -*- mode: objc -*- */
//
// Project: Workspace
//
//
// This application is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public
//
// This application 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
//
// You should have received a copy of the GNU General Public
// Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA.
//
#import <GNUstepGUI/GSDisplayServer.h>
#import <SystemKit/OSEScreen.h>
#import <SystemKit/OSEDisplay.h>
#import <Processes/ProcessManager.h>
#import <Viewers/ShelfView.h>
#import "Recycler.h"
#import "RecyclerIcon.h"
#include <core/util.h>
#include <core/string_utils.h>
#include <xrandr.h>
#include <dock.h>
static Recycler *recycler = nil;
@implementation RecyclerIconView
// Class variables
static NSCell *dragCell = nil;
static NSCell *tileCell = nil;
+ (void)initialize
{
NSImage *tileImage;
NSSize iconSize = NSMakeSize(64, 64);
dragCell = [[NSCell alloc] initImageCell:nil];
[dragCell setBordered:NO];
tileImage = [[GSCurrentServer() iconTileImage] copy];
[tileImage setScalesWhenResized:NO];
[tileImage setSize:iconSize];
tileCell = [[NSCell alloc] initImageCell:tileImage];
RELEASE(tileImage);
[tileCell setBordered:NO];
}
- (id)initWithFrame:(NSRect)frame
{
self = [super initWithFrame:frame];
[self registerForDraggedTypes:@[ NSFilenamesPboardType ]];
return self;
}
- (BOOL)acceptsFirstMouse:(NSEvent *)theEvent
{
return YES;
}
- (void)setImage:(NSImage *)anImage
{
[dragCell setImage:anImage];
[self setNeedsDisplay:YES];
}
- (void)drawRect:(NSRect)rect
{
NSSize iconSize = NSMakeSize(64, 64);
NSDebugLLog(@"Recycler", @"Recycler View: drawRect!");
[tileCell drawWithFrame:NSMakeRect(0, 0, iconSize.width, iconSize.height) inView:self];
[dragCell drawWithFrame:NSMakeRect(0, 0, iconSize.width, iconSize.height) inView:self];
}
// --- Drag and Drop
static int imageNumber;
static NSDate *date = nil;
static NSTimeInterval tInterval = 0;
- (void)animate
{
NSString *imageName;
if (([NSDate timeIntervalSinceReferenceDate] - tInterval) < 0.1) {
return;
}
tInterval = [NSDate timeIntervalSinceReferenceDate];
if (++imageNumber > 4)
imageNumber = 1;
imageName = [NSString stringWithFormat:@"recycler-%i", imageNumber];
[self setImage:[NSImage imageNamed:imageName]];
}
- (NSDragOperation)draggingEntered:(id<NSDraggingInfo>)sender
{
NSDebugLLog(@"Recycler", @"Recycler: dragging entered!");
NSArray *sourcePaths;
BOOL draggedFromRecycler = NO;
sourcePaths = [[sender draggingPasteboard] propertyListForType:NSFilenamesPboardType];
for (NSString *path in sourcePaths) {
if ([path rangeOfString:recycler.path].location != NSNotFound) {
NSDebugLLog(@"Recycler", @"%@ is in %@", path, recycler.path);
draggedFromRecycler = YES;
break;
}
}
if (draggedFromRecycler != NO) {
draggingMask = NSDragOperationNone;
} else {
draggingMask = (NSDragOperationMove | NSDragOperationDelete);
tInterval = [NSDate timeIntervalSinceReferenceDate];
}
return draggingMask;
}
- (void)draggingExited:(id<NSDraggingInfo>)sender
{
NSDebugLLog(@"Recycler", @"Recycler: dragging exited!");
[recycler updateIconImage];
}
- (NSDragOperation)draggingUpdated:(id<NSDraggingInfo>)sender
{
if (draggingMask != NSDragOperationNone) {
[self animate];
}
return draggingMask;
}
- (BOOL)prepareForDragOperation:(id<NSDraggingInfo>)sender
{
NSDebugLLog(@"Recycler", @"Recycler: prepare fo dragging");
return ([sender draggingSourceOperationMask] == NSDragOperationNone) ? NO : YES;
}
- (BOOL)performDragOperation:(id<NSDraggingInfo>)sender
{
BOOL result = NO;
NSPasteboard *dragPb = [sender draggingPasteboard];
NSArray *types = [dragPb types];
NSString *dbPath;
NSMutableDictionary *db;
NSFileManager *fm = [NSFileManager defaultManager];
NSMutableArray *items;
NSString *sourceDir;
dbPath = [recycler.path stringByAppendingPathComponent:@".recycler.db"];
if ([fm fileExistsAtPath:dbPath]) {
db = [[NSMutableDictionary alloc] initWithContentsOfFile:dbPath];
} else {
db = [NSMutableDictionary new];
}
NSDebugLLog(@"Recycler", @"Recycler: perform dragging");
[recycler setIconImage:[NSImage imageNamed:@"recycler"]];
if ([types containsObject:NSFilenamesPboardType] == YES) {
NSString *name, *path;
items = [[dragPb propertyListForType:NSFilenamesPboardType] mutableCopy];
sourceDir = [[items objectAtIndex:0] stringByDeletingLastPathComponent];
for (NSUInteger i = 0; i < [items count]; i++) {
path = [items objectAtIndex:i];
name = [path lastPathComponent];
[db setObject:[path stringByDeletingLastPathComponent] forKey:name];
[items replaceObjectAtIndex:i withObject:name];
}
[[ProcessManager shared] startOperationWithType:MoveOperation
source:sourceDir
target:[recycler path]
files:items];
[items release];
[db writeToFile:dbPath atomically:YES];
result = YES;
}
[db release];
[recycler updateIconImage];
return result;
}
- (void)concludeDragOperation:(id<NSDraggingInfo>)sender
{
NSDebugLLog(@"Recycler", @"Recycler: conclude dragging");
}
@end
// WindowMaker's callback funtion on mouse click.
// LMB click goes to dock app core window.
// RMB click goes to root window (handles by event.c in WindowMaker).
void _recyclerMouseDown(WObjDescriptor *desc, XEvent *event)
{
NSEvent *theEvent;
WAppIcon *aicon = desc->parent;
NSInteger clickCount = 1;
XUngrabPointer(dpy, CurrentTime);
if (event->xbutton.button == Button1) {
if (IsDoubleClick(wDefaultScreen(), event)) {
clickCount = 2;
}
// Handle move of icon
if (aicon->dock) {
wHandleAppIconMove(aicon, event);
}
theEvent = [NSEvent mouseEventWithType:NSLeftMouseDown
location:NSMakePoint(event->xbutton.x, event->xbutton.y)
modifierFlags:0
timestamp:(NSTimeInterval)event->xbutton.time / 1000.0
windowNumber:[[recycler appIcon] windowNumber]
context:[[recycler appIcon] graphicsContext]
eventNumber:event->xbutton.serial
clickCount:clickCount
pressure:1.0];
[recycler performSelectorOnMainThread:@selector(mouseDown:)
withObject:theEvent
waitUntilDone:NO];
} else if (event->xbutton.button == Button3) {
// This will bring menu of active application on screen at mouse pointer
event->xbutton.window = event->xbutton.root;
// XSendEvent(dpy, event->xbutton.root, False, ButtonPressMask, event);
XSendEvent(dpy, aicon->dock->icon_array[0]->icon->icon_win, False, ButtonPressMask, event);
}
}
@implementation RecyclerIcon
// Search for position in Dock for new Recycler
+ (int)newPositionInDock:(WDock *)dock
{
WAppIcon *btn;
int position = 0;
for (position = dock->max_icons - 1; position > 0; position--) {
if ((btn = dock->icon_array[position]) == NULL) {
break;
}
}
return position;
}
+ (WAppIcon *)createAppIconForDock:(WDock *)dock
{
WAppIcon *btn;
int rec_pos = [RecyclerIcon newPositionInDock:dock];
btn = wAppIconCreateForDock(dock->screen_ptr, "-", "Recycler", "GNUstep", TILE_NORMAL);
btn->yindex = rec_pos;
btn->flags.running = 1;
btn->flags.launching = 0;
btn->flags.lock = 1;
btn->command = wstrdup("-");
btn->dnd_command = NULL;
btn->paste_command = NULL;
btn->icon->core->descriptor.handle_mousedown = _recyclerMouseDown;
return btn;
}
+ (void)rebuildDock:(WDock *)dock
{
WScreen *scr = dock->screen_ptr;
int new_max_icons = wDockMaxIcons(dock->screen_ptr);
WAppIcon **new_icon_array;
new_icon_array = wmalloc(sizeof(WAppIcon *) * new_max_icons);
dock->icon_count = 0;
for (int i = 0; i < new_max_icons; i++) {
if (dock->icon_array[i] == NULL || i >= dock->max_icons) {
new_icon_array[i] = NULL;
} else {
new_icon_array[i] = dock->icon_array[i];
dock->icon_count++;
}
}
wfree(dock->icon_array);
dock->icon_array = new_icon_array;
dock->max_icons = new_max_icons;
}
+ (WAppIcon *)recyclerAppIconForDock:(WDock *)dock
{
WAppIcon *btn = NULL;
WAppIcon *rec_btn = NULL;
btn = dock->screen_ptr->app_icon_list;
while (btn->next) {
if (!strcmp(btn->wm_instance, "Recycler")) {
rec_btn = btn;
break;
}
btn = btn->next;
}
if (!rec_btn) {
rec_btn = [RecyclerIcon createAppIconForDock:dock];
} else {
// Recycler icon can be restored from state file
btn->icon->core->descriptor.handle_mousedown = _recyclerMouseDown;
}
return rec_btn;
}
+ (void)updatePositionInDock:(WDock *)dock
{
WAppIcon *rec_icon = [RecyclerIcon recyclerAppIconForDock:dock];
int yindex, new_yindex, max_position;
yindex = rec_icon->yindex;
// 1. Screen dimensions may have changed - rebuild Dock.
// If main display height reduced - Recycler will be removed from Dock.
[RecyclerIcon rebuildDock:dock];
// 2. Get new position for Recycler.
new_yindex = [RecyclerIcon newPositionInDock:dock];
// 3. Place Recycler to the new position if Dock has room.
if (rec_icon->flags.docked) {
if (new_yindex == 0) {
// Dock has no room
NSDebugLLog(@"Recycler", @"Recycler detach");
wDockDetach(dock, rec_icon);
} else {
if (yindex != new_yindex) {
NSDebugLLog(@"Recycler", @"Recycler: reattach");
wDockReattachIcon(dock, rec_icon, 0, new_yindex);
}
}
} else if (new_yindex > 0) {
NSDebugLLog(@"Recycler", @"Recycler: attach at %i", new_yindex);
wDockAttachIcon(dock, rec_icon, 0, new_yindex, NO);
}
}
- (void)_initDefaults
{
[super _initDefaults];
[self setTitle:@"Recycler"];
[self setExcludedFromWindowsMenu:YES];
[self setReleasedWhenClosed:NO];
if ([[NSUserDefaults standardUserDefaults] boolForKey:@"GSAllowWindowsOverIcons"] == YES) {
_windowLevel = NSDockWindowLevel;
}
}
- (id)initWithWindowRef:(void *)xWindow recycler:(Recycler *)theRecycler
{
self = [super initWithWindowRef:xWindow];
recycler = theRecycler;
[[NSNotificationCenter defaultCenter]
removeObserver:self
name:NSApplicationDidChangeScreenParametersNotification
object:NSApp];
return self;
}
- (BOOL)canBecomeMainWindow
{
return NO;
}
- (BOOL)canBecomeKeyWindow
{
return NO;
}
- (BOOL)worksWhenModal
{
return YES;
}
@end
```
|
```smalltalk
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using Foundation;
using NUnit.Framework;
namespace MonoTouchFixtures {
[TestFixture]
[Preserve (AllMembers = true)]
public class VerifyAllTestsArePreserved {
[Test]
public void Test ()
{
if (TestRuntime.IsLinkAll) {
// The linker will remove the Preserve attribute, so this test doesn't make sense when the linker is enabled.
// Also it wouldn't find tests without the Preserve attribute reliably anyway, since the linker would link those tests away.
Assert.Ignore ("This test does not make sense to run with the linker enabled for all assemblies.");
}
TestAssembly (typeof (TestRuntime).Assembly);
}
#if NET
[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "This test verifies that all tests have been correctly preserved, and fails if that's not the case. It'll thus fail if the trimmer removed anything it didn't expect - and is then technically trimmer safe in that it's aware and react accordingly if there's any behavioral change when the trimmer is enabled.")]
[UnconditionalSuppressMessage ("Trimming", "IL2045", Justification = "This test verifies that all tests have been correctly preserved, and fails if that's not the case. It'll thus fail if the trimmer removed anything it didn't expect - and is then technically trimmer safe in that it's aware and react accordingly if there's any behavioral change when the trimmer is enabled.")]
#endif
void TestAssembly (Assembly asm)
{
var failedTypes = new List<string> ();
foreach (var type in asm.GetTypes ()) {
if (!IsTestFixture (type))
continue;
if (type.IsDefined (typeof (PreserveAttribute)))
continue;
if (Skip (type))
continue;
failedTypes.Add (type.FullName);
}
Assert.That (failedTypes, Is.Empty, "Failed types");
}
bool Skip (Type type)
{
switch (type.FullName) {
// We get the System.Drawing tests from source from mono, so we can't fix them (easily).
case "MonoTests.System.Drawing.PointTest":
case "MonoTests.System.Drawing.PointFTest":
case "MonoTests.System.Drawing.TestRectangle":
case "MonoTests.System.Drawing.TestRectangleF":
case "MonoTests.System.Drawing.SizeTest":
case "MonoTests.System.Drawing.SizeFTest":
return true;
}
return false;
}
#if NET
[UnconditionalSuppressMessage ("Trimming", "IL2070", Justification = "This test verifies that all tests have been correctly preserved, and fails if that's not the case. It'll thus fail if the trimmer removed anything it didn't expect - and is then technically trimmer safe in that it's aware and react accordingly if there's any behavioral change when the trimmer is enabled.")]
#endif
bool IsTestFixture (Type type)
{
// what's a test fixture: path_to_url
if (type is null || type == typeof (object))
return false;
if (type.IsDefined (typeof (TestFixtureAttribute)))
return true;
if (IsTestFixture (type.BaseType))
return true;
// "So long as the class contains at least one method marked with the Test, TestCase or TestCaseSource attribute, it will be treated as a test fixture."
foreach (var method in type.GetMethods (BindingFlags.Public | BindingFlags.Instance)) {
if (method.IsDefined (typeof (TestAttribute)))
return true;
if (method.IsDefined (typeof (TestCaseAttribute)))
return true;
if (method.IsDefined (typeof (TestCaseSourceAttribute)))
return true;
}
return false;
}
}
}
```
|
The American Legion, commonly known as the Legion, is a non-profit organization of U.S. war veterans headquartered in Indianapolis, Indiana. It comprises state, U.S. territory, and overseas departments, in turn, made up of local posts. The organization was formed on March 15, 1919, in Paris, France, by a thousand officers and men of the American Expeditionary Forces (A. E. F.), and it was chartered on September 16, 1919, by the United States Congress.
The Legion played the leading role in drafting and passing the Servicemen's Readjustment Act of 1944, commonly known as the "G.I. Bill". In addition to organizing commemorative events, members assist at Department of Veterans Affairs (VA) hospitals and clinics. It is active in issue-oriented U.S. politics. Its primary political activity is lobbying on behalf of interests of veterans and service members, including support for benefits such as pensions and the Veterans Health Administration. It has also historically promoted Americanism, individual obligation to the community, state, and nation; peace and goodwill.
History
The American Legion was established on March 15, 1919, in Paris, France, by delegates to a caucus meeting from units of the American Expeditionary Forces (A. E. F.), which adopted a tentative constitution. The action of the Paris Caucus was confirmed and endorsed by a similar meeting held in St. Louis, Missouri, from May 8 to 10, 1919, when the Legion was formally recognized by the troops who served in the United States. The Paris Caucus appointed an Executive Committee of seventeen officers and men to represent the troops in France in the conduct of the Legion. The St. Louis caucus appointed a similar Committee of Seventeen. These two national executive committees amalgamated and were the initial governing body of the Legion. The temporary headquarters was located in New York.
List of founding members
The men who initiated the formation of the Legion:
Lieutenant Colonel Theodore Roosevelt, Jr., of the First Division
Colonel Henry D. Lindsley, formerly Mayor of Dallas, Texas
Colonel Horatio Nelson Jackson, US Army first person to drive an automobile across America
Sergeant John J. Sullivan, of Seattle
Lieutenant Colonel Franklin D'Olier, of Philadelphia
Ex-Senator Luke Lea, of Tennessee
Lieutenant Colonel Frederick Huidekoper, of Washington, D.C.
Major Redmond C. Stewart, of Baltimore
Wagoner Dale Shaw, of Iowa
Lieutenant Colonel George A. White, of Oregon
"Bill" Donovan, of the "Fighting 69th"
Major Thomas R. Gowenlock, of Illinois
Lieutenant Earl B. Dickerson, of the 92nd Division
Sergeant Alvin York, of Tennessee
Colonel John Price Jackson, of the S. O. S.
Lieutenant Colonel "Jack" Greenway, of Arizona
Sergeant Roy C. Haines, of Maine
G. Edward Buxton, Jr., of Rhode Island
Eric Fisher Wood, of Pennsylvania
Chaplain John W. Inzer, of Alabama
Lieutenant Colonel David M. Goodrich, of Akron
Chief Petty Officer B. J. Goldberg, of Chicago
"Tom" Miller, of Delaware
Major Alex. Laughlin, Jr., of Pittsburgh
Major Henry Leonard, of the Marine Corps
Dwight F. Davis, of the 35th Division
Corporal Charles S. Pew, of Montana
Brigadier General William G. Price, of the 28th Division
Bishop Charles H. Brent, Senior Chaplain of the A. E. F.
Major General John F. O'Ryan, of the 27th Division
Stewart Edward White, of California
Private Jesus M. Baca, of New Mexico
Brigadier General Charles H. Cole, of the 26th Division
Sergeant E. L. Malsbary, of Nevada
Lieutenant Samuel Gompers, Jr., of New York
Colonel Henry L. Stimson, Ex-Secretary of War
Lieutenant Colonel Charles W. Whittlesey, Commander of the "Lost Battalion"
Roy Hoffman, of Oklahoma
Lieutenant Colonel A. Piatt Andrew, of the American Ambulance in France
Brigadier General Harvey J. Moss, of the State of Washington
John MacVicar, Mayor of Des Moines before the War
Sergeant George H. H. Pratt, of New Orleans
Colonel F. W. Galbraith, of Cincinnati
Corporal Joseph H. Fountain, of Vermont
Devereux Milburn, of the 78th Division
Lieutenant Colonel Wilbur Smith, of the 89th Division
Sergeant Theodore Myers, of Pennsylvania
Colonel Bennett C. Clark, son of Champ Clark
Robert Bacon, Ex-Secretary of State
Headquarters
The national headquarters, informally known as American Legion headquarters, is located on the Indiana World War Memorial Plaza at 700 North Pennsylvania Street, Indianapolis, Indiana. It is the headquarters for the National Commander of The American Legion and also houses the archives, library, Membership, Internal Affairs, Public Relations, and The American Legion magazine's editorial offices. The national headquarters has expanded multiple times since its establishment.
Emblem
The World War I Victory Button on a narrow circular band of blue enamel, containing the words "American Legion" in gold letters, forms the central element of the American Legion Emblem. The Legion emblem or "button" was officially adopted by the National Executive Committee of The American Legion on July 9, 1919.
Eligibility
Membership in The American Legion was originally restricted to soldiers, sailors, and marines who served honorably between April 6, 1917, and November 11, 1918. Eligibility has since been expanded to include personnel who served on active duty in the Armed Forces of the United States or armed forces associated with the U.S., between December 7, 1941, through a date of cessation of hostilities as determined by the federal government, and was an American citizen when they entered that service or continues to serve honorably. U.S. Merchant Marines who served between December 7, 1941, and December 31, 1946, are also eligible. Honorary, associate, social, or guest memberships in the Legion are not permitted. Members must be eligible through the nature and timing of their military service.
The following is a list of eligibility dates the American Legion uses to determine membership eligibility.
Publication
The official publication, originally known as The American Legion Weekly, launched on July 4, 1919. In 1926, the Legion Weekly reduced the frequency of publication and was renamed The American Legion Monthly. In 1936, the publication's name and volume numbering system changed again, this time to The American Legion.
The American Legion Digital Archive online offers scans of "American Legion magazine, national meeting digests, newsletters, press releases, and other publications published by the national organization."
Notable members
Notable members of The American Legion have included:
List of national commanders
Franklin D'Olier, of Pennsylvania, 1919–1920
Frederic W. Galbraith, Jr., of Ohio, 1920–1921
John G. Emery, of Michigan, 1921
Hanford MacNider, of Iowa, 1921–1922
Alvin M. Owsley, of Texas, 1922–1923
John R. Quinn, of California, 1923–1924
James A. Drain, of Washington, 1924–1925
John R. McQuigg, of Ohio, 1925–1926
Howard P. Savage, of Illinois, 1926–1927
Edward E. Spafford, of New York, 1927–1928
Paul V. McNutt, of Indiana, 1928–1929
O. L. Bodenhamer, of Arkansas, 1929–1930
Ralph T. O'Neil, of Kansas, 1930–1931
Henry L. Stevens, Jr., of North Carolina, 1931–1932
Louis A. Johnson, of West Virginia, 1932–1933
Edward A. Hayes, of Illinois, 1933–1934
Frank N. Belgrano, of California, 1934–1935
Ray Murphy, of Iowa, 1935–1936
Harry W. Colmery, of Kansas, 1936–1937
Daniel J. Doherty, of Massachusetts, 1937–1938
Stephen F. Chadwick, of Washington, 1938–1939
Raymond J. Kelly, of Michigan, 1939–1940
Milo J. Warner, of Ohio, 1940–1941
Lynn U. Stambaugh, of North Dakota, 1941–1942
Roane Waring, of Tennessee, 1942–1943
Warren H. Atherton, of California, 1943–1944
Edward N. Scheiberling, of New York, 1944–1945
John Stelle, of Illinois, 1945–1946
Paul H. Griffith, of Pennsylvania, 1946–1947
James F. O'Neill, of New Hampshire, 1947–1948
S. Perry Brown, of Texas, 1948–1949
George N. Craig, of Indiana, 1949–1950
Erle Cocke, Jr., of Georgia, 1950–1951
Donald R. Wilson, of West Virginia, 1951–1952
Lewis K. Gough, of California, 1952–1953
Arthur J. Connell, of Connecticut, 1953–1954
Seaborn P. Collins, of New Mexico, 1954–1955
J. Addington Wagner, of Michigan, 1955–1956
Dan Daniel, of Virginia, 1956–1957
John S. Gleason, Jr., of Illinois, 1957–1958
Preston J. Moore, of Oklahoma, 1958–1959
Martin B. McKneally, of New York, 1959–1960
William R. Burke, of California, 1960–1961
Charles L. Bacon, of Missouri, 1961–1962
James E. Powers, of Georgia, 1962–1963
Daniel F. Foley, of Minnesota, 1963–1964
Donald E. Johnson, of Iowa, 1964–1965
L. Eldon James, of Virginia, 1965–1966
John E. Davis, of North Dakota, 1966–1967
William E. Galbraith, of Nebraska, 1967–1968
William C. Doyle, of New Jersey, 1968–1969
J. Milton Patrick, of Oklahoma, 1969–1970
Alfred P. Chamie, of California, 1970–1971
John H. Geiger, of Illinois, 1971–1972
Joe L. Matthews, of Texas, 1972–1973
Robert E. L. Eaton, of Maryland, 1972–1973
James M. Wagonseller, of Ohio, 1974–1975
Harry G. Wiles, of Kansas, 1975–1976
William J. Rogers, of Maine, 1976–1977
Robert C. Smith, of Louisiana, 1977–1978
John M. Carey, of Michigan, 1978–1979
Frank I. Hamilton, of Indiana, 1979–1980
Michael J. Kogutek, of New York, 1980–1981
Jack W. Flynt, of Texas, 1981–1982
Al Keller, Jr., of Illinois, 1982–1983
Keith A. Kreul, of Wisconsin, 1983–1984
Clarence M. Bacon, of Maryland, 1984–1985
Dale L. Renaud, of Iowa, 1985–1986
James P. Dean, of Mississippi, 1986–1987
John P. Comer, of Massachusetts, 1987–1988
H. F. Gierke III, of North Dakota, 1988–1989
Miles S. Epling, of West Virginia, 1989–1990
Robert S. Turner, of Georgia, 1990–1991
Dominic D. DiFrancesco, of Pennsylvania, 1991–1992
Roger A. Munson, of Ohio, 1992–1993
Bruce Thiesen, of California, 1993–1994
William M. Detweiler, of Louisiana, 1994–1995
Daniel A. Ludwig, of Minnesota, 1995–1996
Joseph J. Frank, of Missouri, 1996–1997
Anthony G. Jordan, of Maine, 1997–1998
Harold L. Miller, of Virginia, 1998–1999
Alan G. Lance, Sr., of Idaho, 1999–2000
Ray G. Smith, of North Carolina, 2000–2001
Richard J. Santos, of Maryland, 2001–2002
Ronald F. Conley, of Pennsylvania, 2002–2003
John A. Brieden III, of Texas, 2003–2004
Thomas P. Cadmus, of Michigan, 2004–2005
Thomas L. Bock, of Colorado, 2005–2006
Paul A. Morin, of Massachusetts, 2006–2007
Martin F. Conatser, of Illinois, 2007–2008
David K. Rehbein, of Iowa, 2008–2009
Clarence E. Hill, of Florida, 2009–2010
Jimmie L. Foster, of Alaska, 2010–2011
Fang A. Wong, of New York, 2011–2012
James E. Koutz, of Indiana, 2012–2013
Daniel Dellinger, of Virginia, 2013–2014
Michael D. Helm, of Nebraska, 2014–2015
Dale Barnett, of Georgia, 2015–2016
Charles E. Schmidt, of Oregon, 2016–2017
Denise H. Rohan, of Wisconsin, 2017–2018
Brett P. Reistad, of Virginia, 2018–2019
James W. Oxford, of North Carolina, 2019–2021
Paul E. Dillard, of Texas, 2021–2022
Vincent J. Troiola, of New York, 2022–2023
List of honorary commanders
Marshal Ferdinand Foch, of the French Army
General John J. Pershing, Commander in Chief of the A. E. F.
List of past national commanders by vote of national conventions
Henry D. Lindsley, of Texas, 1919
Milton J. Foreman, of Illinois, 1921
Bennett Champ Clark, of Missouri, 1926
Theodore Roosevelt, Jr., of New York, 1949
Eric Fisher Wood, of Pennsylvania, 1955
Thomas W. Miller, of Nevada, 1968
Maurice Stember, of New York, 1975
Hamilton Fish III, of New York, 1979
E. Roy Stone, Jr., of South Carolina, 1987
Robert W. Spanogle, of Michigan, 2008
USS Liberty survivors
American Legion events have long been off-limits to survivors of the 1967 Israeli attack on the USS Liberty. Legion leaders forbid Liberty survivors from having a booth at their national conventions and censor any internal discussion about the attack.
On August 24, 2017, American Legion members approved and passed Resolution 40, which called for a full U.S. government investigation of the attack but continues to prohibit Liberty survivors from disseminating information about the attack at Legion conventions. This resolution went unanswered by Legion leadership. Previous resolutions had similarly failed to generate action by Legion leadership.
See also
Freedom Bell, American Legion
List of members of the American Legion
List of American Legion buildings
List of veterans' organizations
References
Citations
General sources
Further reading
External links
Official
General information
American Legion politician members at The Political Graveyard
The American Legion Centennial Celebration
Archives
Washington American Legion Records, 1919–1920. 4 microfilm reels. At the Labor Archives of Washington, University of Washington Libraries Special Collections.
Stephen Fowler Chadwick Papers, 1917–1974. 21.1 cubic feet. At the Labor Archives of Washington, University of Washington Libraries Special Collections.
1919 establishments in France
501(c)(19) nonprofit organizations
Advocacy groups in the United States
Aftermath of World War I in France
Aftermath of World War I in the United States
American veterans' organizations
Anti-communist organizations in the United States
Charities based in Indiana
Lobbying organizations in the United States
Magazine publishing companies of the United States
Nonpartisan organizations in the United States
Non-profit organizations based in Indianapolis
Organizations established in 1919
Patriotic and national organizations chartered by the United States Congress
Service organizations based in the United States
United States military support organizations
|
The 1906 German football championship was the fourth competition for the national championship of Germany. Held under the auspices of the German Football Association (DFB), eight teams competed for the title. For the first time only champions of regional football associations were admitted to the championship, excluding champions of local associations such as the Verband Magdeburger Ballspielvereine (Association of Magdeburg ballgame clubs). An exception was the situation in Berlin where two associations — the Verband Berliner Ballspielvereine (VBB) and the Märkischer Fußballbund (MFB) — existed. Both their champions were admitted, as were defending champions Berliner TuFC Union 92. This led to three teams from Berlin competing in the final tournament.
Qualified teams
The qualified teams:
Competition
Quarter-finals
Semi-finals
Final
References
German football championship seasons
1
German
|
```php
<?php
/**
* FecShop file.
*
* @link path_to_url
* @license path_to_url
*/
?>
<?php
$jsOptions = [
# js config 1
[
'options' => [
'position' => 'POS_END',
],
'js' =>[
'js/jquery-3.0.0.min.js',
'js/jquery.lazyload.min.js',
'js/js.js',
],
],
];
# css config
$cssOptions = [
# css config 1.
[
'css' =>[
'css/style.css',
],
],
];
\Yii::$service->page->asset->jsOptions = \yii\helpers\ArrayHelper::merge($jsOptions, \Yii::$service->page->asset->jsOptions);
\Yii::$service->page->asset->cssOptions = \yii\helpers\ArrayHelper::merge($cssOptions, \Yii::$service->page->asset->cssOptions);
\Yii::$service->page->asset->register($this);
?>
<?php $this->beginPage() ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "path_to_url">
<html xmlns="path_to_url" xml:lang="<?= $currentLangCode = Yii::$service->store->currentLangCode; ?>" lang="<?= $currentLangCode ?>">
<head>
<?= Yii::$service->page->widget->render('base/head',$this); ?>
</head>
<body>
<?= Yii::$service->page->widget->render('base/beforeContent',$this); ?>
<?php $this->beginBody() ?>
<header id="header">
<?= Yii::$service->page->widget->render('base/header',$this); ?>
<?= Yii::$service->page->widget->render('base/menu',$this); ?>
</header>
<div class="main-container">
<?= $content; ?>
</div>
<div class="footer-container">
<?= Yii::$service->page->widget->render('base/footer',$this); ?>
</div>
<?= Yii::$service->page->widget->render('base/trace',$this); ?>
<?= Yii::$service->page->widget->render('base/scroll',$this); ?>
<?php $this->endBody() ?>
</body>
</html>
<?php $this->endPage() ?>
```
|
```xml
const foo1: your_sha256_hashoooooo<`Hello, ${keyof World}`> = a;
```
|
```objective-c
//
// NSData+APNSToken.h
// IOS-Categories
//
// Created by Jakey on 15/8/7.
//
#import <Foundation/Foundation.h>
@interface NSData (APNSToken)
/**
* @brief APNS NSDatatoken
*
* @return token
*/
- (NSString *)APNSToken;
@end
```
|
Powielin is a village in the administrative district of Gmina Winnica, within Pułtusk County, Masovian Voivodeship, in east-central Poland. It lies approximately south-west of Pułtusk and north of Warsaw.
References
Powielin
|
```xml
//
//
// Microsoft Bot Framework: path_to_url
//
// Bot Framework Emulator Github:
// path_to_url
//
// All rights reserved.
//
// 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.
//
// your_sha256_hash--
// Proxy support
// eslint-disable-next-line @typescript-eslint/no-var-requires
const path = require('path');
// eslint-disable-next-line @typescript-eslint/no-var-requires
const fs = require('fs');
// eslint-disable-next-line @typescript-eslint/no-var-requires
const nodeFetch = require('node-fetch');
const ROOT_PATH = '';
const caPath = process.env.HTTPS_PROXY_CA && path.resolve(ROOT_PATH, process.env.HTTPS_PROXY_CA);
// eslint-disable-next-line security/detect-non-literal-fs-filename
const ca = caPath && fs.readFileSync(caPath);
// fetch is used globally by importing the module
// eslint-disable-next-line @typescript-eslint/no-unused-vars
declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
(global as any).fetch = function(...args: any[]) {
const [urlOrRequest, requestInit = {}] = args;
// No Proxy
if (!process.env.HTTPS_PROXY) {
return nodeFetch(...args);
}
const url: URL = new URL(typeof urlOrRequest === 'string' ? urlOrRequest : urlOrRequest.url);
// Reference: path_to_url
const noProxyList = (process.env.NO_PROXY || '')
.split(',')
.map(x =>
x
.trim()
.toLowerCase()
.replace(/^\*/, '')
)
.filter(x => x)
.map(name => ({
name,
isDomain: name.startsWith('.'),
}));
if (noProxyList.some(x => (x.isDomain ? url.hostname.endsWith(x.name) : url.hostname === x.name))) {
return nodeFetch(...args);
}
// eslint-disable-next-line @typescript-eslint/no-var-requires
const { HttpsProxyAgent } = require('https-proxy-agent');
const agent = new HttpsProxyAgent(process.env.HTTPS_PROXY, { ca });
if (typeof urlOrRequest === 'string') {
requestInit.agent = agent;
} else {
urlOrRequest.agent = agent;
}
return nodeFetch(urlOrRequest, requestInit);
};
```
|
Nadakame Ulakam () is a 2011 Malayalam-language comedy film directed by Viji Thampi and starring Mukesh, Vinu Mohan, Sarayu, and Saranya Mohan in the lead roles. Its songs are composed by veteran music director Johnson with lyrics written by Kaithapram Damodaran Namboothiri. The film was released on 25 February.
Plot
Omanakuttan, is a bank manager, but he is very interested stage plays and he himself has directed and acted in many plays. He is approached by a film crew from town headed by Pavan, to produce their debut venture. Omanakuttan who is a cinema aspirant, agrees to finance the film after he was offered the lead role. Eventually, he learns that neither Pavanan nor his associates know anything about film making. Omanakuttan decides himself to script and direct the film. He completes the film successfully with a limited cast but fails to find a distributor. To find a distributor, Omanakuttan goes to Chennai but fate had something else planned for him there. His bag gets stolen and while chasing the thief, he gets hit by a car. However, the car was that of an accomplished film producer and distributor. After hearing the story of Omanakuttan, he decides to distribute the film, which became a super hit in the box office.
Cast
Soundtrack
"Thevarapoo Malayil (male)" - K. J. Yesudas
"Vanamaali Ninnodakkuzhalil" - K. S. Chithra, Vijay Yesudas
"Pookkila Chithary" - M. G. Sreekumar, Chorus
"Thevarapoo Malayil (female)" - K. S. Chithra
References
External links
Nadakame Ulakam at Oneindia.in
2010s Malayalam-language films
2011 comedy films
2011 films
Films scored by Johnson
Indian comedy films
Films shot in Chennai
Films directed by Viji Thampi
|
```markdown
# ML with TensorFlow Extended (TFX) -- Part 1
The puprpose of this tutorial is to show how to do end-to-end ML with TFX libraries on Google Cloud Platform. This tutorial covers:
1. Data analysis and schema generation with **TF Data Validation**.
2. Data preprocessing with **TF Transform**.
3. Model training with **TF Estimator**.
4. Model evaluation with **TF Model Analysis**.
This notebook has been tested in Jupyter on the Deep Learning VM.
## Setup Cloud environment```
```python
import tensorflow as tf
import tensorflow_data_validation as tfdv
print('TF version: {}'.format(tf.__version__))
print('TFDV version: {}'.format(tfdv.__version__))
```
```python
PROJECT = 'cloud-training-demos' # Replace with your PROJECT
BUCKET = 'cloud-training-demos-ml' # Replace with your BUCKET
REGION = 'us-central1' # Choose an available region for Cloud MLE
import os
os.environ['PROJECT'] = PROJECT
os.environ['BUCKET'] = BUCKET
os.environ['REGION'] = REGION
```
```python
%%bash
gcloud config set project $PROJECT
gcloud config set compute/region $REGION
## ensure we predict locally with our current Python environment
gcloud config set ml_engine/local_python `which python`
```
```markdown
<img valign="middle" src="images/tfx.jpeg">```
```markdown
### UCI Adult Dataset: path_to_urlPredict whether income exceeds $50K/yr based on census data. Also known as "Census Income" dataset.```
```python
DATA_DIR='gs://cloud-samples-data/ml-engine/census/data'
```
```python
import os
TRAIN_DATA_FILE = os.path.join(DATA_DIR, 'adult.data.csv')
EVAL_DATA_FILE = os.path.join(DATA_DIR, 'adult.test.csv')
!gsutil ls -l $TRAIN_DATA_FILE
!gsutil ls -l $EVAL_DATA_FILE
```
```markdown
## 1. Data Analysis
For data analysis, visualization, and schema generation, we use [TensorFlow Data Validation](path_to_url to perform the following:
1. **Analyze** the training data and produce **statistics**.
2. Generate data **schema** from the produced statistics.
3. **Configure** the schema.
4. **Validate** the evaluation data against the schema.
5. **Save** the schema for later use.```
```markdown
### 1.1 Compute and visualise statistics```
```python
HEADER = ['age', 'workclass', 'fnlwgt', 'education', 'education_num',
'marital_status', 'occupation', 'relationship', 'race', 'gender',
'capital_gain', 'capital_loss', 'hours_per_week',
'native_country', 'income_bracket']
TARGET_FEATURE_NAME = 'income_bracket'
TARGET_LABELS = [' <=50K', ' >50K']
WEIGHT_COLUMN_NAME = 'fnlwgt'
```
```python
# This is a convenience function for CSV. We can write a Beam pipeline for other formats.
# path_to_urltrain_stats = tfdv.generate_statistics_from_csv(
data_location=TRAIN_DATA_FILE,
column_names=HEADER,
stats_options=tfdv.StatsOptions(
weight_feature=WEIGHT_COLUMN_NAME,
sample_rate=1.0
)
)
```
```python
tfdv.visualize_statistics(train_stats)
```
```markdown
### 1.2 Infer Schema```
```python
schema = tfdv.infer_schema(statistics=train_stats)
tfdv.display_schema(schema=schema)
```
```python
print(tfdv.get_feature(schema, 'age'))
```
```markdown
### 1.3 Configure Schema```
```python
# Relax the minimum fraction of values that must come from the domain for feature occupation.
occupation = tfdv.get_feature(schema, 'occupation')
occupation.distribution_constraints.min_domain_mass = 0.9
# Add new value to the domain of feature native_country, assuming that we start receiving this
# we won't be able to make great predictions of course, because this country is not part of our
# training data.
native_country_domain = tfdv.get_domain(schema, 'native_country')
native_country_domain.value.append('Egypt')
# All features are by default in both TRAINING and SERVING environments.
schema.default_environment.append('TRAINING')
schema.default_environment.append('EVALUATION')
schema.default_environment.append('SERVING')
# Specify that the class feature is not in SERVING environment.
tfdv.get_feature(schema, TARGET_FEATURE_NAME).not_in_environment.append('SERVING')
```
```python
tfdv.display_schema(schema=schema)
```
```markdown
### 1.4 Validate evaluation data```
```python
eval_stats = tfdv.generate_statistics_from_csv(
EVAL_DATA_FILE,
column_names=HEADER,
stats_options=tfdv.StatsOptions(
weight_feature=WEIGHT_COLUMN_NAME)
)
eval_anomalies = tfdv.validate_statistics(eval_stats, schema, environment='EVALUATION')
tfdv.display_anomalies(eval_anomalies)
```
```markdown
### 1.5 Freeze the schema```
```python
RAW_SCHEMA_LOCATION = 'raw_schema.pbtxt'
```
```python
from tensorflow.python.lib.io import file_io
from google.protobuf import text_format
tfdv.write_schema_text(schema, RAW_SCHEMA_LOCATION)
```
```python
!cat {RAW_SCHEMA_LOCATION}
```
```markdown
```
```markdown
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
---
**Disclaimer**: This is not an official Google product. The sample code provided for an educational purpose.
---```
|
Ziemomysł of Inowrocław (; c. 1245 – October/24 December 1287), was a Polish prince, member of the House of Piast, duke of Inowrocław during 1267-1271 and 1278–1287, and ruler over Bydgoszcz during 1267-1269 and 1278–1287.
Early years
Ziemomysł was the second son of Casimir I of Kuyavia and his second wife Constance, daughter of Henry II the Pious. In 1257 his mother died, and his father soon married for the third time with Euphrosyne, daughter of Casimir I of Opole. Ziemomysł's stepmother soon caused conflicts in the family with her attempts to obtain territorial benefits for her own children (the eldest of them was the future Polish king Władysław the Elbow-high) in detriment of Ziemomysł and his older full-brother Leszek the Black; some chronicles even accused Euphrosyne of attempting to poison both stepsons.
Reign
After his father's death in 1267 Ziemomysł inherited the district of Inowrocław. At the beginning of his reign in the small principality, he managed to survive the invasion of the considerable forces of King Ottokar II of Bohemia, who was bounded to a Crusade against Lithuania. Was probably at this point that Ziemomysł established close contacts with the Teutonic Order and Sambor II, Duke of Pomerelia, alliances which soon brought to him serious troubles - the revolt of his own subjects.
The conflict clearly emerged after Sambor II (his father-in-law since 1268) loaned Ziemomysł some German knights. This preference to foreigners disliked the local knighthood, and caused an armed conflict led by the bishop of Kujawy, Wolimir, in 1269. The rebels called the very known anti-German Bolesław the Pious to help them. Bolesław took Radziejów, Kruszwica and the castle in Bydgoszcz. Only through rapid action did Ziemomysł and the grant to further privileges to Bishop Wolimir allowed him to regain temporary control of his lands.
In 1271, Ziemomysł was involved in the Pomerelian affairs, in which he supported father-in-law Sambor II against Mestwin II. This decision triggered another invasion of Bolesław the Pious, which combined with another revolt of his subjects forced Ziemomysł to escape. Ziemomysł recovered his lands only in 1278 as a result of an agreement between Bolesław the Pious and Leszek the Black in Ląd, where Leszek II returned Inowrocław to his brother only after he promised to take distance himself from all his German advisors. Despite the end of the conflict, Bolesław the Pious kept Radziejów and Kruszwica.
The complete normalization of Ziemomysł's rule took place two years later at the Congress of Rzepka, where after an agreement with Mestwin II, was stipulated that after his death the castellany of Wyszogród had to return to Inowrocław. The final break with his pro-German policy was in 1284, when Ziemomysł supported his brother Leszek in a war against the Teutonic Order. The details of this conflict are unknown. Ziemomysł also began the process of giving Town privileges to his subjects, endowing them upon Gniewkowo.
Ziemomysł died between October and 24 December 1287. It is unknown where he was buried, although is assumed that it happened in the capital of the duchy, Inowrocław.
Marriage and issue
Probably in 1268, Ziemomysł married Salomea, daughter of Duke Sambor II of Pomerania. They had six children:
Euphemia (d. young, 3 March 1268/78).
Fenenna (ca. 1268/77 – 1295) married Andrew III of Hungary.
Constance (1268/80 – 8 August 1331), a nun.
Leszek (1275/76 – after 27 April 1339).
Przemysł (ca. 1278 – November 1338/16 February 1339).
Kazimierz III of Gniewkowo (1280/84 – 22 August 1345/13 May 1350).
Because his sons are minors at the time of his death, his widow and half-brother Władysław I the Elbow-high took the regency on their behalf.
References
1240s births
1287 deaths
Year of birth uncertain
Piast dynasty
13th-century Polish people
People of Byzantine descent
|
```objective-c
//
// Created by liuyubobobo on 7/22/16.
//
#ifndef INC_05_QUICK_SORT_ANOTHER_PARTITION_SORTTESTHELPER_H
#define INC_05_QUICK_SORT_ANOTHER_PARTITION_SORTTESTHELPER_H
#include <iostream>
#include <algorithm>
#include <string>
#include <ctime>
#include <cassert>
using namespace std;
namespace SortTestHelper {
// n,[rangeL, rangeR]
int *generateRandomArray(int n, int range_l, int range_r) {
int *arr = new int[n];
srand(time(NULL));
for (int i = 0; i < n; i++)
arr[i] = rand() % (range_r - range_l + 1) + range_l;
return arr;
}
//
// [0...n-1], swapTimes
// swapTimes
int *generateNearlyOrderedArray(int n, int swapTimes){
int *arr = new int[n];
for(int i = 0 ; i < n ; i ++ )
arr[i] = i;
srand(time(NULL));
for( int i = 0 ; i < swapTimes ; i ++ ){
int posx = rand()%n;
int posy = rand()%n;
swap( arr[posx] , arr[posy] );
}
return arr;
}
// a,
int *copyIntArray(int a[], int n){
int *arr = new int[n];
//* VS, copy, for:)
copy(a, a+n, arr);
return arr;
}
// arr
template<typename T>
void printArray(T arr[], int n) {
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
return;
}
// arr
template<typename T>
bool isSorted(T arr[], int n) {
for (int i = 0; i < n - 1; i++)
if (arr[i] > arr[i + 1])
return false;
return true;
}
// sortarr
template<typename T>
void testSort(const string &sortName, void (*sort)(T[], int), T arr[], int n) {
clock_t startTime = clock();
sort(arr, n);
clock_t endTime = clock();
cout << sortName << " : " << double(endTime - startTime) / CLOCKS_PER_SEC << " s"<<endl;
assert(isSorted(arr, n));
return;
}
};
#endif //INC_05_QUICK_SORT_ANOTHER_PARTITION_SORTTESTHELPER_H
```
|
Henrik Holm (born 1968) is a Swedish tennis player.
Henrik Holm may also refer to:
Henrik Holm (actor) (born 1995), Norwegian actor
Henrik Holm (ice hockey) (born 1990), Norwegian ice hockey player
|
```css
#pm_menu {
position: fixed; height: 100%; width: 300px; background:red; top: 0; z-index: 1001;
-webkit-animation: backSlideOut .3s both ease;
-moz-animation: backSlideOut .3s both ease;
animation: backSlideOut .3s both ease;
}
#pm_menu.pm_open{
left: 0px;
-webkit-animation: backSlideIn .5s both ease;
-moz-animation: backSlideIn .5s both ease;
animation: backSlideIn .5s both ease;
}
#pm_menu.pm_initial{
display: none;
}
.pm_overlay{
width: 100%;
height: 100%;
padding: 0;
margin: 0;
position: fixed;
z-index: 1000;
background: rgba(0,0,0,0.5);
left: 0;
top: 0;
-webkit-animation: fadeOut .5s both ease;
-moz-animation: fadeOut .5s both ease;
animation: fadeOut .5s both ease;
}
.pm_overlay.pm_show{
display: block;
-webkit-animation: fadeIn .3s both ease;
-moz-animation: fadeIn .3s both ease;
animation: fadeIn .3s both ease;
}
.pm_overlay.pm_hide{
display: none;
}
/* Keyframes */
/*empty*/
@-webkit-keyframes empty {
0% {opacity: 1}
}
@-moz-keyframes empty {
0% {opacity: 1}
}
@keyframes empty {
0% {opacity: 1}
}
@-webkit-keyframes fadeIn {
0% { opacity:0; }
100% { opacity:1; }
}
@-moz-keyframes fadeIn {
0% { opacity:0; }
100% { opacity:1; }
}
@keyframes fadeIn {
0% { opacity:0; }
100% { opacity:1; }
}
@-webkit-keyframes fadeOut {
0% { opacity:1; }
100% { opacity:0; display: none; }
}
@-moz-keyframes fadeOut {
0% { opacity:1; }
100% { opacity:0; display: none; }
}
@keyframes fadeOut {
0% { opacity:1; }
100% { opacity:0; display: none; }
}
@-webkit-keyframes backSlideOut {
0% { opacity: 1; -webkit-transform: translateX(0px); }
50% { opacity: 1; }
100% { opacity: 0; -webkit-transform: translateX(-100%); }
}
@-moz-keyframes backSlideOut {
0% { opacity: 1; -webkit-transform: translateX(0px); }
50% { opacity: 1; }
100% { opacity: 0; -webkit-transform: translateX(-100%); }
}
@keyframes backSlideOut {
0% { opacity: 1; -webkit-transform: translateX(0px); }
50% { opacity: 1; }
100% { opacity: 0; -webkit-transform: translateX(-100%); }
}
@-webkit-keyframes backSlideIn {
0% { opacity: 0; -webkit-transform: translateX(-100%); }
100% { opacity: 1; -webkit-transform: translateX(0px); }
}
@-moz-keyframes backSlideIn {
0% { opacity: 0; -webkit-transform: translateX(-100%); }
100% { opacity: 1; -webkit-transform: translateX(0px); }
}
@keyframes backSlideIn {
0% { opacity: 0; -webkit-transform: translateX(-100%); }
100% { opacity: 1; -webkit-transform: translateX(0px); }
}
```
|
The Lamson PL-1 Quark was an American high-wing, single-seat, glider that was designed and constructed by Philip Lamson, first flying in early 1965.
Design and development
Lamson designed and built the Quark in 1964 as a lighthearted experimental aircraft project to create a prone position-pilot glider. To this end the pilot was accommodated lying down with his head in the nose bubble.
The PL-1 is constructed from fiberglass, with the wings made from a balsa-fiberglass sandwich that was laid up in a female mold. The wing was originally of span, but this was quickly increased to with tip extensions and finally the aircraft received a new three-piece wing. The airfoil was an Irv Culver modification to the NACA 0012. The landing gear was a monowheel, with small wing tip skids.
Soaring Magazine described the aircraft as "purely a lark and a quirky lark at that". The designer described the performance as "somewhere between a Nimbus and a Rogallo".
Only one Quark was built and it was registered with the US Federal Aviation Administration in the Experimental - amateur-built category.
Operational history
The aircraft logged about 300 hours in its wingspan version. The Quark was removed from the FAA registry on 13 August 2002 and the aircraft likely no longer exists.
Specifications (Quark)
See also
References
1960s United States sailplanes
Homebuilt aircraft
Prone pilot aircraft
Aircraft first flown in 1965
|
```kotlin
package com.camerakit.type
enum class CameraFlash {
OFF,
ON,
AUTO,
TORCH;
}
```
|
```python
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
#
# path_to_url
#
# Unless required by applicable law or agreed to in writing,
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# specific language governing permissions and limitations
# pylint: disable=invalid-name, line-too-long, unused-variable, too-many-locals
"""Convolution in python"""
import numpy as np
import scipy.signal
from tvm.topi.nn.utils import get_pad_tuple
def _conv2d_nhwc_python(a_np, w_np, stride, padding):
"""Convolution operator in NHWC layout.
Parameters
----------
a_np : numpy.ndarray
4-D with shape [batch, in_height, in_width, in_channel]
w_np : numpy.ndarray
4-D with shape [filter_height, filter_width, in_channel, num_filter]
stride : int or a list/tuple of two ints
Stride size, or [stride_height, stride_width]
padding : int or str or a list/tuple of two ints
Padding size, or ['VALID', 'SAME'], or [pad_height, pad_width]
Returns
-------
b_np : np.ndarray
4-D with shape [batch, out_height, out_width, out_channel]
"""
batch, in_height, in_width, in_channel = a_np.shape
kernel_h, kernel_w, _, num_filter = w_np.shape
if isinstance(stride, int):
stride_h = stride_w = stride
else:
stride_h, stride_w = stride
pad_top, pad_left, pad_bottom, pad_right = get_pad_tuple(padding, (kernel_h, kernel_w))
pad_h = pad_top + pad_bottom
pad_w = pad_left + pad_right
# compute the output shape
out_channel = num_filter
out_height = (in_height - kernel_h + pad_h) // stride_h + 1
out_width = (in_width - kernel_w + pad_w) // stride_w + 1
# change the layout from NHWC to NCHW
at = a_np.transpose((0, 3, 1, 2))
wt = w_np.transpose((3, 2, 0, 1))
bt = np.zeros((batch, out_channel, out_height, out_width))
# computation
for n in range(batch):
for f in range(out_channel):
for c in range(in_channel):
if pad_h > 0 or pad_w > 0:
apad = np.zeros((in_height + pad_h, in_width + pad_w))
apad[pad_top : pad_top + in_height, pad_left : pad_left + in_width] = at[n, c]
else:
apad = at[n, c]
out = scipy.signal.convolve2d(apad, np.rot90(np.rot90(wt[f, c])), mode="valid")
bt[n, f] += out[::stride_h, ::stride_w]
return bt.transpose((0, 2, 3, 1))
def conv2d_nhwc_python(a_np, w_np, stride, padding, groups=1):
"""Convolution operator in NHWC layout.
Parameters
----------
a_np : numpy.ndarray
4-D with shape [batch, in_height, in_width, in_channel]
w_np : numpy.ndarray
4-D with shape [filter_height, filter_width, in_channel // groups, num_filter]
stride : int or a list/tuple of two ints
Stride size, or [stride_height, stride_width]
padding : int or str or a list/tuple of 2 or 4 ints
Padding size, or ['VALID', 'SAME'], or
[pad_height, pad_width] for 2 ints, or
[pad_top, pad_left, pad_bottom, pad_right] for 2 ints
groups : int
Number of groups
Returns
-------
b_np : np.ndarray
4-D with shape [batch, out_height, out_width, out_channel]
"""
a_slices = np.array_split(a_np, groups, axis=3)
w_slices = np.array_split(w_np, groups, axis=3)
b_slices = [
_conv2d_nhwc_python(a_slice, w_slice, stride, padding)
for a_slice, w_slice in zip(a_slices, w_slices)
]
b_np = np.concatenate(b_slices, axis=3)
return b_np
```
|
```c++
/*
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing,
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* specific language governing permissions and limitations
*/
/*!
* \file tvm/src/pass/lower_custom_datatypes.cc
* \brief Pass for lowering custom datatypes
*/
#include <tvm/runtime/registry.h>
#include <tvm/target/target.h>
#include <tvm/tir/op.h>
#include <tvm/tir/stmt_functor.h>
#include <tvm/tir/transform.h>
#include "../../target/datatype/registry.h"
namespace tvm {
namespace tir {
/*!
* \brief Helper mutator to implement lowering of custom datatypes.
*
* Lowering datatypes works as follows: for every expression containing a custom
* datatype, we search for a global (registered by the implementer of the custom
* datatype) for lowering this type of expression, and uses it to lower the
* expression.
*/
class CustomDatatypesLowerer : public StmtExprMutator {
public:
explicit CustomDatatypesLowerer(const std::string& target) : target_(target) {}
PrimExpr VisitExpr_(const CastNode* op) final {
auto type_code = op->dtype.code();
auto src_type_code = op->value.dtype().code();
// If either datatype is a registered custom datatype, we must lower.
bool to_be_lowered = datatype::Registry::Global()->GetTypeRegistered(type_code) ||
datatype::Registry::Global()->GetTypeRegistered(src_type_code);
PrimExpr expr = StmtExprMutator::VisitExpr_(op);
if (to_be_lowered) {
auto lower = datatype::GetCastLowerFunc(target_, type_code, src_type_code);
ICHECK(lower) << "Cast lowering function for target " << target_ << " destination type "
<< static_cast<unsigned>(type_code) << " source type "
<< static_cast<unsigned>(src_type_code) << " not found";
return (*lower)(expr);
}
return expr;
}
PrimExpr VisitExpr_(const FloatImmNode* imm) final {
auto type_code = imm->dtype.code();
auto e = GetRef<PrimExpr>(imm);
if (datatype::Registry::Global()->GetTypeRegistered(type_code)) {
auto lower = datatype::GetFloatImmLowerFunc(target_, type_code);
ICHECK(lower) << "FloatImm lowering function for target " << target_ << " type "
<< static_cast<unsigned>(type_code) << " not found";
return (*lower)(e);
}
return e;
}
PrimExpr VisitExpr_(const VarNode* op) final {
Var var = GetRef<Var>(op);
auto itr = var_remap_.find(var);
if (itr != var_remap_.end()) {
return itr->second;
} else {
return std::move(var);
}
}
Stmt VisitStmt_(const AllocateNode* allocate) final {
bool to_be_lowered = datatype::Registry::Global()->GetTypeRegistered(allocate->dtype.code());
if (to_be_lowered) {
auto new_allocate_type = DataType::UInt(allocate->dtype.bits(), allocate->dtype.lanes());
auto new_buffer_var =
Var(allocate->buffer_var->name_hint, PointerType(PrimType(new_allocate_type)));
var_remap_[allocate->buffer_var] = new_buffer_var;
Stmt stmt = StmtExprMutator::VisitStmt_(allocate);
allocate = stmt.as<AllocateNode>();
return Allocate(new_buffer_var, new_allocate_type, allocate->extents, allocate->condition,
allocate->body, allocate->annotations);
} else {
return StmtExprMutator::VisitStmt_(allocate);
}
}
Stmt VisitStmt_(const DeclBufferNode* op) final {
auto node = Downcast<DeclBuffer>(StmtExprMutator::VisitStmt_(op));
return VisitBufferAccess(std::move(node));
}
PrimExpr VisitExpr_(const BufferLoadNode* op) final {
auto node = Downcast<BufferLoad>(StmtExprMutator::VisitExpr_(op));
auto modified = VisitBufferAccess(node);
// Not needed for BufferStoreNode, so we can't just call
// LegalizeDtype() in VisitBufferAccess.
if (node.same_as(modified)) {
return std::move(node);
} else {
auto writer = modified.CopyOnWrite();
writer->LegalizeDType();
return std::move(modified);
}
}
Stmt VisitStmt_(const BufferStoreNode* op) final {
auto node = Downcast<BufferStore>(StmtExprMutator::VisitStmt_(op));
return VisitBufferAccess(std::move(node));
}
template <typename Node>
Node VisitBufferAccess(Node node) {
Buffer new_buf = GetRemappedBuffer(node->buffer);
if (!new_buf.same_as(node->buffer)) {
auto writer = node.CopyOnWrite();
writer->buffer = new_buf;
}
return node;
}
Buffer GetRemappedBuffer(Buffer buf) {
auto key = buf;
auto cache_it = buf_remap_.find(key);
if (cache_it != buf_remap_.end()) {
return cache_it->second;
}
bool to_be_lowered = datatype::Registry::Global()->GetTypeRegistered(buf->dtype.code());
if (to_be_lowered) {
auto new_load_type = DataType::UInt(buf->dtype.bits());
auto writer = buf.CopyOnWrite();
writer->dtype = new_load_type;
auto var_it = var_remap_.find(buf->data);
if (var_it != var_remap_.end()) {
writer->data = var_it->second;
}
}
buf_remap_[key] = buf;
return buf;
}
Stmt VisitStmt_(const AttrStmtNode* op) final {
Stmt ret = StmtExprMutator::VisitStmt_(op);
op = ret.as<AttrStmtNode>();
// Due to legacy reasons, some attr node can contain
// information(e.g. alignment) of buffer variables.
// remap these vars when needed
// TODO(tvm-team): remove the rewriting once the buffer var
// attrs are being refactored into the corresponding definition node
if (auto var_node = op->node.as<Var>()) {
auto it = var_remap_.find(var_node.value());
if (it != var_remap_.end()) {
return AttrStmt(it->second, op->attr_key, op->value, op->body);
}
}
return ret;
}
PrimExpr VisitExpr_(const CallNode* call) final {
bool to_be_lowered = datatype::Registry::Global()->GetTypeRegistered(call->dtype.code());
PrimExpr expr = StmtExprMutator::VisitExpr_(call);
call = expr.as<CallNode>();
if (to_be_lowered) {
auto op = call->op.as<OpNode>();
ICHECK(op != nullptr) << "Lowering non-intrinsic Calls not implemented";
auto lower = datatype::GetIntrinLowerFunc(target_, op->name, call->dtype.code());
ICHECK(lower) << "Intrinsic lowering function for target " << target_ << ", intrinsic name "
<< op->name << ", type " << static_cast<unsigned>(call->dtype.code())
<< " not found";
return (*lower)(expr);
}
return expr;
}
#define TVM_DEFINE_MUTATE_CUSTOM_DTYPE(OP, NodeName) \
PrimExpr VisitExpr_(const NodeName* op) final { \
auto type_code = op->dtype.code(); \
bool to_be_lowered = datatype::Registry::Global()->GetTypeRegistered(type_code); \
PrimExpr expr = StmtExprMutator::VisitExpr_(op); \
op = expr.as<NodeName>(); \
if (to_be_lowered) { \
auto lower = datatype::Get##OP##LowerFunc(target_, type_code); \
ICHECK(lower) << #OP " lowering function for target " << target_ << " type " \
<< static_cast<unsigned>(type_code) << " not found"; \
return (*lower)(expr); \
} \
return expr; \
}
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(Add, AddNode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(Sub, SubNode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(Mul, MulNode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(Div, DivNode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(Mod, ModNode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(Min, MinNode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(Max, MaxNode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(EQ, EQNode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(NE, NENode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(LT, LTNode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(LE, LENode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(GT, GTNode);
TVM_DEFINE_MUTATE_CUSTOM_DTYPE(GE, GENode);
// Later changes may need to add more mutate functions as we support workloads with more ops.
#undef TVM_DEFINE_MUTATE_CUSTOM_DTYPE
private:
std::string target_;
// remap buffer vars
std::unordered_map<Var, Var> var_remap_;
std::unordered_map<Buffer, Buffer, ObjectPtrHash, ObjectPtrEqual> buf_remap_;
};
namespace transform {
Pass LowerCustomDatatypes() {
auto pass_func = [](PrimFunc f, IRModule m, PassContext ctx) {
auto* n = f.CopyOnWrite();
auto target = f->GetAttr<Target>(tvm::attr::kTarget);
ICHECK(target.defined()) << "LowerCustomDatatypes: Require the target attribute";
n->body = CustomDatatypesLowerer(target.value()->kind->name)(std::move(n->body));
return f;
};
return CreatePrimFuncPass(pass_func, 0, "tir.LowerCustomDatatypes", {});
}
TVM_REGISTER_GLOBAL("tir.transform.LowerCustomDatatypes").set_body_typed(LowerCustomDatatypes);
} // namespace transform
} // namespace tir
} // namespace tvm
```
|
```c
/* Implement classes and message passing for Objective C.
Free Software Foundation, Inc.
Contributed by Steve Naroff.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC 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
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* Purpose: This module implements the Objective-C 4.0 language.
compatibility issues (with the Stepstone translator):
- does not recognize the following 3.3 constructs.
@requires, @classes, @messages, = (...)
- methods with variable arguments must conform to ANSI standard.
- tagged structure definitions that appear in BOTH the interface
and implementation are not allowed.
- public/private: all instance variables are public within the
context of the implementation...I consider this to be a bug in
the translator.
- statically allocated objects are not supported. the user will
receive an error if this service is requested.
code generation `options':
*/
#include "config.h"
#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "expr.h"
#include "c-tree.h"
#include "c-common.h"
#include "flags.h"
#include "objc-act.h"
#include "input.h"
#include "except.h"
#include "function.h"
#include "output.h"
#include "toplev.h"
#include "ggc.h"
#include "debug.h"
#include "target.h"
#include "diagnostic.h"
/* This is the default way of generating a method name. */
/* I am not sure it is really correct.
Perhaps there's a danger that it will make name conflicts
if method names contain underscores. -- rms. */
#ifndef OBJC_GEN_METHOD_LABEL
#define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
do { \
char *temp; \
sprintf ((BUF), "_%s_%s_%s_%s", \
((IS_INST) ? "i" : "c"), \
(CLASS_NAME), \
((CAT_NAME)? (CAT_NAME) : ""), \
(SEL_NAME)); \
for (temp = (BUF); *temp; temp++) \
if (*temp == ':') *temp = '_'; \
} while (0)
#endif
/* These need specifying. */
#ifndef OBJC_FORWARDING_STACK_OFFSET
#define OBJC_FORWARDING_STACK_OFFSET 0
#endif
#ifndef OBJC_FORWARDING_MIN_OFFSET
#define OBJC_FORWARDING_MIN_OFFSET 0
#endif
/* Set up for use of obstacks. */
#include "obstack.h"
/* This obstack is used to accumulate the encoding of a data type. */
static struct obstack util_obstack;
/* This points to the beginning of obstack contents,
so we can free the whole contents. */
char *util_firstobj;
/* for encode_method_def */
#include "rtl.h"
/* The version identifies which language generation and runtime
the module (file) was compiled for, and is recorded in the
module descriptor. */
#define OBJC_VERSION (flag_next_runtime ? 5 : 8)
#define PROTOCOL_VERSION 2
/* (Decide if these can ever be validly changed.) */
#define OBJC_ENCODE_INLINE_DEFS 0
#define OBJC_ENCODE_DONT_INLINE_DEFS 1
/*** Private Interface (procedures) ***/
/* Used by compile_file. */
static void init_objc PARAMS ((void));
static void finish_objc PARAMS ((void));
/* Code generation. */
static void synth_module_prologue PARAMS ((void));
static tree build_constructor PARAMS ((tree, tree));
static rtx build_module_descriptor PARAMS ((void));
static tree init_module_descriptor PARAMS ((tree));
static tree build_objc_method_call PARAMS ((int, tree, tree,
tree, tree, tree));
static void generate_strings PARAMS ((void));
static tree get_proto_encoding PARAMS ((tree));
static void build_selector_translation_table PARAMS ((void));
static tree objc_add_static_instance PARAMS ((tree, tree));
static tree build_ivar_template PARAMS ((void));
static tree build_method_template PARAMS ((void));
static tree build_private_template PARAMS ((tree));
static void build_class_template PARAMS ((void));
static void build_selector_template PARAMS ((void));
static void build_category_template PARAMS ((void));
static tree build_super_template PARAMS ((void));
static tree build_category_initializer PARAMS ((tree, tree, tree,
tree, tree, tree));
static tree build_protocol_initializer PARAMS ((tree, tree, tree,
tree, tree));
static void synth_forward_declarations PARAMS ((void));
static void generate_ivar_lists PARAMS ((void));
static void generate_dispatch_tables PARAMS ((void));
static void generate_shared_structures PARAMS ((void));
static tree generate_protocol_list PARAMS ((tree));
static void generate_forward_declaration_to_string_table PARAMS ((void));
static void build_protocol_reference PARAMS ((tree));
static tree build_keyword_selector PARAMS ((tree));
static tree synth_id_with_class_suffix PARAMS ((const char *, tree));
static void generate_static_references PARAMS ((void));
static int check_methods_accessible PARAMS ((tree, tree,
int));
static void encode_aggregate_within PARAMS ((tree, int, int,
int, int));
static const char *objc_demangle PARAMS ((const char *));
static void objc_expand_function_end PARAMS ((void));
/* Hash tables to manage the global pool of method prototypes. */
hash *nst_method_hash_list = 0;
hash *cls_method_hash_list = 0;
static size_t hash_func PARAMS ((tree));
static void hash_init PARAMS ((void));
static void hash_enter PARAMS ((hash *, tree));
static hash hash_lookup PARAMS ((hash *, tree));
static void hash_add_attr PARAMS ((hash, tree));
static tree lookup_method PARAMS ((tree, tree));
static tree lookup_instance_method_static PARAMS ((tree, tree));
static tree lookup_class_method_static PARAMS ((tree, tree));
static tree add_class PARAMS ((tree));
static void add_category PARAMS ((tree, tree));
enum string_section
{
class_names, /* class, category, protocol, module names */
meth_var_names, /* method and variable names */
meth_var_types /* method and variable type descriptors */
};
static tree add_objc_string PARAMS ((tree,
enum string_section));
static tree get_objc_string_decl PARAMS ((tree,
enum string_section));
static tree build_objc_string_decl PARAMS ((enum string_section));
static tree build_selector_reference_decl PARAMS ((void));
/* Protocol additions. */
static tree add_protocol PARAMS ((tree));
static tree lookup_protocol PARAMS ((tree));
static void check_protocol_recursively PARAMS ((tree, tree));
static tree lookup_and_install_protocols PARAMS ((tree));
/* Type encoding. */
static void encode_type_qualifiers PARAMS ((tree));
static void encode_pointer PARAMS ((tree, int, int));
static void encode_array PARAMS ((tree, int, int));
static void encode_aggregate PARAMS ((tree, int, int));
static void encode_bitfield PARAMS ((int));
static void encode_type PARAMS ((tree, int, int));
static void encode_field_decl PARAMS ((tree, int, int));
static void really_start_method PARAMS ((tree, tree));
static int comp_method_with_proto PARAMS ((tree, tree));
static int comp_proto_with_proto PARAMS ((tree, tree));
static tree get_arg_type_list PARAMS ((tree, int, int));
static tree expr_last PARAMS ((tree));
/* Utilities for debugging and error diagnostics. */
static void warn_with_method PARAMS ((const char *, int, tree));
static void error_with_ivar PARAMS ((const char *, tree, tree));
static char *gen_method_decl PARAMS ((tree, char *));
static char *gen_declaration PARAMS ((tree, char *));
static void gen_declaration_1 PARAMS ((tree, char *));
static char *gen_declarator PARAMS ((tree, char *,
const char *));
static int is_complex_decl PARAMS ((tree));
static void adorn_decl PARAMS ((tree, char *));
static void dump_interface PARAMS ((FILE *, tree));
/* Everything else. */
static tree define_decl PARAMS ((tree, tree));
static tree lookup_method_in_protocol_list PARAMS ((tree, tree, int));
static tree lookup_protocol_in_reflist PARAMS ((tree, tree));
static tree create_builtin_decl PARAMS ((enum tree_code,
tree, const char *));
static void setup_string_decl PARAMS ((void));
static void build_string_class_template PARAMS ((void));
static tree my_build_string PARAMS ((int, const char *));
static void build_objc_symtab_template PARAMS ((void));
static tree init_def_list PARAMS ((tree));
static tree init_objc_symtab PARAMS ((tree));
static void forward_declare_categories PARAMS ((void));
static void generate_objc_symtab_decl PARAMS ((void));
static tree build_selector PARAMS ((tree));
static tree build_typed_selector_reference PARAMS ((tree, tree));
static tree build_selector_reference PARAMS ((tree));
static tree build_class_reference_decl PARAMS ((void));
static void add_class_reference PARAMS ((tree));
static tree build_protocol_template PARAMS ((void));
static tree build_descriptor_table_initializer PARAMS ((tree, tree));
static tree build_method_prototype_list_template PARAMS ((tree, int));
static tree build_method_prototype_template PARAMS ((void));
static int forwarding_offset PARAMS ((tree));
static tree encode_method_prototype PARAMS ((tree, tree));
static tree generate_descriptor_table PARAMS ((tree, const char *,
int, tree, tree));
static void generate_method_descriptors PARAMS ((tree));
static tree build_tmp_function_decl PARAMS ((void));
static void hack_method_prototype PARAMS ((tree, tree));
static void generate_protocol_references PARAMS ((tree));
static void generate_protocols PARAMS ((void));
static void check_ivars PARAMS ((tree, tree));
static tree build_ivar_list_template PARAMS ((tree, int));
static tree build_method_list_template PARAMS ((tree, int));
static tree build_ivar_list_initializer PARAMS ((tree, tree));
static tree generate_ivars_list PARAMS ((tree, const char *,
int, tree));
static tree build_dispatch_table_initializer PARAMS ((tree, tree));
static tree generate_dispatch_table PARAMS ((tree, const char *,
int, tree));
static tree build_shared_structure_initializer PARAMS ((tree, tree, tree, tree,
tree, int, tree, tree,
tree));
static void generate_category PARAMS ((tree));
static int is_objc_type_qualifier PARAMS ((tree));
static tree adjust_type_for_id_default PARAMS ((tree));
static tree check_duplicates PARAMS ((hash));
static tree receiver_is_class_object PARAMS ((tree));
static int check_methods PARAMS ((tree, tree, int));
static int conforms_to_protocol PARAMS ((tree, tree));
static void check_protocol PARAMS ((tree, const char *,
const char *));
static void check_protocols PARAMS ((tree, const char *,
const char *));
static tree encode_method_def PARAMS ((tree));
static void gen_declspecs PARAMS ((tree, char *, int));
static void generate_classref_translation_entry PARAMS ((tree));
static void handle_class_ref PARAMS ((tree));
static void generate_struct_by_value_array PARAMS ((void))
ATTRIBUTE_NORETURN;
static void encode_complete_bitfield PARAMS ((int, tree, int));
/*** Private Interface (data) ***/
/* Reserved tag definitions. */
#define TYPE_ID "id"
#define TAG_OBJECT "objc_object"
#define TAG_CLASS "objc_class"
#define TAG_SUPER "objc_super"
#define TAG_SELECTOR "objc_selector"
#define UTAG_CLASS "_objc_class"
#define UTAG_IVAR "_objc_ivar"
#define UTAG_IVAR_LIST "_objc_ivar_list"
#define UTAG_METHOD "_objc_method"
#define UTAG_METHOD_LIST "_objc_method_list"
#define UTAG_CATEGORY "_objc_category"
#define UTAG_MODULE "_objc_module"
#define UTAG_SYMTAB "_objc_symtab"
#define UTAG_SUPER "_objc_super"
#define UTAG_SELECTOR "_objc_selector"
#define UTAG_PROTOCOL "_objc_protocol"
#define UTAG_METHOD_PROTOTYPE "_objc_method_prototype"
#define UTAG_METHOD_PROTOTYPE_LIST "_objc__method_prototype_list"
/* Note that the string object global name is only needed for the
NeXT runtime. */
#define STRING_OBJECT_GLOBAL_NAME "_NSConstantStringClassReference"
#define PROTOCOL_OBJECT_CLASS_NAME "Protocol"
static const char *TAG_GETCLASS;
static const char *TAG_GETMETACLASS;
static const char *TAG_MSGSEND;
static const char *TAG_MSGSENDSUPER;
static const char *TAG_EXECCLASS;
static const char *default_constant_string_class_name;
/* The OCTI_... enumeration itself is in objc/objc-act.h. */
tree objc_global_trees[OCTI_MAX];
static void handle_impent PARAMS ((struct imp_entry *));
struct imp_entry *imp_list = 0;
int imp_count = 0; /* `@implementation' */
int cat_count = 0; /* `@category' */
static int method_slot = 0; /* Used by start_method_def, */
#define BUFSIZE 1024
static char *errbuf; /* Buffer for error diagnostics */
/* Data imported from tree.c. */
extern enum debug_info_type write_symbols;
/* Data imported from toplev.c. */
extern const char *dump_base_name;
static int flag_typed_selectors;
FILE *gen_declaration_file;
/* Tells "encode_pointer/encode_aggregate" whether we are generating
type descriptors for instance variables (as opposed to methods).
Type descriptors for instance variables contain more information
than methods (for static typing and embedded structures). */
static int generating_instance_variables = 0;
/* Some platforms pass small structures through registers versus
through an invisible pointer. Determine at what size structure is
the transition point between the two possibilities. */
static void
generate_struct_by_value_array ()
{
tree type;
tree field_decl, field_decl_chain;
int i, j;
int aggregate_in_mem[32];
int found = 0;
/* Presumably no platform passes 32 byte structures in a register. */
for (i = 1; i < 32; i++)
{
char buffer[5];
/* Create an unnamed struct that has `i' character components */
type = start_struct (RECORD_TYPE, NULL_TREE);
strcpy (buffer, "c1");
field_decl = create_builtin_decl (FIELD_DECL,
char_type_node,
buffer);
field_decl_chain = field_decl;
for (j = 1; j < i; j++)
{
sprintf (buffer, "c%d", j + 1);
field_decl = create_builtin_decl (FIELD_DECL,
char_type_node,
buffer);
chainon (field_decl_chain, field_decl);
}
finish_struct (type, field_decl_chain, NULL_TREE);
aggregate_in_mem[i] = aggregate_value_p (type);
if (!aggregate_in_mem[i])
found = 1;
}
/* We found some structures that are returned in registers instead of memory
so output the necessary data. */
if (found)
{
for (i = 31; i >= 0; i--)
if (!aggregate_in_mem[i])
break;
printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n\n", i);
/* The first member of the structure is always 0 because we don't handle
structures with 0 members */
printf ("static int struct_forward_array[] = {\n 0");
for (j = 1; j <= i; j++)
printf (", %d", aggregate_in_mem[j]);
printf ("\n};\n");
}
exit (0);
}
const char *
objc_init (filename)
const char *filename;
{
filename = c_objc_common_init (filename);
if (filename == NULL)
return filename;
/* Force the line number back to 0; check_newline will have
raised it to 1, which will make the builtin functions appear
not to be built in. */
lineno = 0;
/* If gen_declaration desired, open the output file. */
if (flag_gen_declaration)
{
register char * const dumpname = concat (dump_base_name, ".decl", NULL);
gen_declaration_file = fopen (dumpname, "w");
if (gen_declaration_file == 0)
fatal_io_error ("can't open %s", dumpname);
free (dumpname);
}
if (flag_next_runtime)
{
TAG_GETCLASS = "objc_getClass";
TAG_GETMETACLASS = "objc_getMetaClass";
TAG_MSGSEND = "objc_msgSend";
TAG_MSGSENDSUPER = "objc_msgSendSuper";
TAG_EXECCLASS = "__objc_execClass";
default_constant_string_class_name = "NSConstantString";
}
else
{
TAG_GETCLASS = "objc_get_class";
TAG_GETMETACLASS = "objc_get_meta_class";
TAG_MSGSEND = "objc_msg_lookup";
TAG_MSGSENDSUPER = "objc_msg_lookup_super";
TAG_EXECCLASS = "__objc_exec_class";
default_constant_string_class_name = "NXConstantString";
flag_typed_selectors = 1;
}
objc_ellipsis_node = make_node (ERROR_MARK);
init_objc ();
if (print_struct_values)
generate_struct_by_value_array ();
return filename;
}
void
finish_file ()
{
c_objc_common_finish_file ();
/* Finalize Objective-C runtime data. No need to generate tables
and code if only checking syntax. */
if (!flag_syntax_only)
finish_objc ();
if (gen_declaration_file)
fclose (gen_declaration_file);
}
static tree
define_decl (declarator, declspecs)
tree declarator;
tree declspecs;
{
tree decl = start_decl (declarator, declspecs, 0, NULL_TREE);
finish_decl (decl, NULL_TREE, NULL_TREE);
return decl;
}
/* Return 1 if LHS and RHS are compatible types for assignment or
various other operations. Return 0 if they are incompatible, and
return -1 if we choose to not decide. When the operation is
REFLEXIVE, check for compatibility in either direction.
For statically typed objects, an assignment of the form `a' = `b'
is permitted if:
`a' is of type "id",
`a' and `b' are the same class type, or
`a' and `b' are of class types A and B such that B is a descendant of A. */
static tree
lookup_method_in_protocol_list (rproto_list, sel_name, class_meth)
tree rproto_list;
tree sel_name;
int class_meth;
{
tree rproto, p;
tree fnd = 0;
for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
{
p = TREE_VALUE (rproto);
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
if ((fnd = lookup_method (class_meth
? PROTOCOL_CLS_METHODS (p)
: PROTOCOL_NST_METHODS (p), sel_name)))
;
else if (PROTOCOL_LIST (p))
fnd = lookup_method_in_protocol_list (PROTOCOL_LIST (p),
sel_name, class_meth);
}
else
{
; /* An identifier...if we could not find a protocol. */
}
if (fnd)
return fnd;
}
return 0;
}
static tree
lookup_protocol_in_reflist (rproto_list, lproto)
tree rproto_list;
tree lproto;
{
tree rproto, p;
/* Make sure the protocol is supported by the object on the rhs. */
if (TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE)
{
tree fnd = 0;
for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
{
p = TREE_VALUE (rproto);
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
if (lproto == p)
fnd = lproto;
else if (PROTOCOL_LIST (p))
fnd = lookup_protocol_in_reflist (PROTOCOL_LIST (p), lproto);
}
if (fnd)
return fnd;
}
}
else
{
; /* An identifier...if we could not find a protocol. */
}
return 0;
}
/* Return 1 if LHS and RHS are compatible types for assignment or
various other operations. Return 0 if they are incompatible, and
return -1 if we choose to not decide (because the types are really
just C types, not ObjC specific ones). When the operation is
REFLEXIVE (typically comparisons), check for compatibility in
either direction; when it's not (typically assignments), don't.
This function is called in two cases: when both lhs and rhs are
pointers to records (in which case we check protocols too), and
when both lhs and rhs are records (in which case we check class
inheritance only).
Warnings about classes/protocols not implementing a protocol are
emitted here (multiple of those warnings might be emitted for a
single line!); generic warnings about incompatible assignments and
lacks of casts in comparisons are/must be emitted by the caller if
we return 0.
*/
int
objc_comptypes (lhs, rhs, reflexive)
tree lhs;
tree rhs;
int reflexive;
{
/* New clause for protocols. */
/* Here we manage the case of a POINTER_TYPE = POINTER_TYPE. We only
manage the ObjC ones, and leave the rest to the C code. */
if (TREE_CODE (lhs) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (lhs)) == RECORD_TYPE
&& TREE_CODE (rhs) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (rhs)) == RECORD_TYPE)
{
int lhs_is_proto = IS_PROTOCOL_QUALIFIED_ID (lhs);
int rhs_is_proto = IS_PROTOCOL_QUALIFIED_ID (rhs);
if (lhs_is_proto)
{
tree lproto, lproto_list = TYPE_PROTOCOL_LIST (lhs);
tree rproto, rproto_list;
tree p;
/* <Protocol> = <Protocol> */
if (rhs_is_proto)
{
rproto_list = TYPE_PROTOCOL_LIST (rhs);
if (!reflexive)
{
/* An assignment between objects of type 'id
<Protocol>'; make sure the protocol on the lhs is
supported by the object on the rhs. */
for (lproto = lproto_list; lproto;
lproto = TREE_CHAIN (lproto))
{
p = TREE_VALUE (lproto);
rproto = lookup_protocol_in_reflist (rproto_list, p);
if (!rproto)
warning
("object does not conform to the `%s' protocol",
IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
}
return 1;
}
else
{
/* Obscure case - a comparison between two objects
of type 'id <Protocol>'. Check that either the
protocol on the lhs is supported by the object on
the rhs, or viceversa. */
/* Check if the protocol on the lhs is supported by the
object on the rhs. */
for (lproto = lproto_list; lproto;
lproto = TREE_CHAIN (lproto))
{
p = TREE_VALUE (lproto);
rproto = lookup_protocol_in_reflist (rproto_list, p);
if (!rproto)
{
/* Check failed - check if the protocol on the rhs
is supported by the object on the lhs. */
for (rproto = rproto_list; rproto;
rproto = TREE_CHAIN (rproto))
{
p = TREE_VALUE (rproto);
lproto = lookup_protocol_in_reflist (lproto_list,
p);
if (!lproto)
{
/* This check failed too: incompatible */
return 0;
}
}
return 1;
}
}
return 1;
}
}
/* <Protocol> = <class> * */
else if (TYPED_OBJECT (TREE_TYPE (rhs)))
{
tree rname = TYPE_NAME (TREE_TYPE (rhs));
tree rinter;
/* Make sure the protocol is supported by the object on
the rhs. */
for (lproto = lproto_list; lproto; lproto = TREE_CHAIN (lproto))
{
p = TREE_VALUE (lproto);
rproto = 0;
rinter = lookup_interface (rname);
while (rinter && !rproto)
{
tree cat;
rproto_list = CLASS_PROTOCOL_LIST (rinter);
rproto = lookup_protocol_in_reflist (rproto_list, p);
/* If the underlying ObjC class does not have
the protocol we're looking for, check for "one-off"
protocols (e.g., `NSObject<MyProt> *foo;') attached
to the rhs. */
if (!rproto)
{
rproto_list = TYPE_PROTOCOL_LIST (TREE_TYPE (rhs));
rproto = lookup_protocol_in_reflist (rproto_list, p);
}
/* Check for protocols adopted by categories. */
cat = CLASS_CATEGORY_LIST (rinter);
while (cat && !rproto)
{
rproto_list = CLASS_PROTOCOL_LIST (cat);
rproto = lookup_protocol_in_reflist (rproto_list, p);
cat = CLASS_CATEGORY_LIST (cat);
}
rinter = lookup_interface (CLASS_SUPER_NAME (rinter));
}
if (!rproto)
warning ("class `%s' does not implement the `%s' protocol",
IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (rhs))),
IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
}
return 1;
}
/* <Protocol> = id */
else if (TYPE_NAME (TREE_TYPE (rhs)) == objc_object_id)
{
return 1;
}
/* <Protocol> = Class */
else if (TYPE_NAME (TREE_TYPE (rhs)) == objc_class_id)
{
return 0;
}
/* <Protocol> = ?? : let comptypes decide. */
return -1;
}
else if (rhs_is_proto)
{
/* <class> * = <Protocol> */
if (TYPED_OBJECT (TREE_TYPE (lhs)))
{
if (reflexive)
{
tree rname = TYPE_NAME (TREE_TYPE (lhs));
tree rinter;
tree rproto, rproto_list = TYPE_PROTOCOL_LIST (rhs);
/* Make sure the protocol is supported by the object on
the lhs. */
for (rproto = rproto_list; rproto;
rproto = TREE_CHAIN (rproto))
{
tree p = TREE_VALUE (rproto);
tree lproto = 0;
rinter = lookup_interface (rname);
while (rinter && !lproto)
{
tree cat;
tree lproto_list = CLASS_PROTOCOL_LIST (rinter);
lproto = lookup_protocol_in_reflist (lproto_list, p);
/* If the underlying ObjC class does not
have the protocol we're looking for,
check for "one-off" protocols (e.g.,
`NSObject<MyProt> *foo;') attached to the
lhs. */
if (!lproto)
{
lproto_list = TYPE_PROTOCOL_LIST
(TREE_TYPE (lhs));
lproto = lookup_protocol_in_reflist
(lproto_list, p);
}
/* Check for protocols adopted by categories. */
cat = CLASS_CATEGORY_LIST (rinter);
while (cat && !lproto)
{
lproto_list = CLASS_PROTOCOL_LIST (cat);
lproto = lookup_protocol_in_reflist (lproto_list,
p);
cat = CLASS_CATEGORY_LIST (cat);
}
rinter = lookup_interface (CLASS_SUPER_NAME
(rinter));
}
if (!lproto)
warning ("class `%s' does not implement the `%s' protocol",
IDENTIFIER_POINTER (TYPE_NAME
(TREE_TYPE (lhs))),
IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
}
return 1;
}
else
return 0;
}
/* id = <Protocol> */
else if (TYPE_NAME (TREE_TYPE (lhs)) == objc_object_id)
{
return 1;
}
/* Class = <Protocol> */
else if (TYPE_NAME (TREE_TYPE (lhs)) == objc_class_id)
{
return 0;
}
/* ??? = <Protocol> : let comptypes decide */
else
{
return -1;
}
}
else
{
/* Attention: we shouldn't defer to comptypes here. One bad
side effect would be that we might loose the REFLEXIVE
information.
*/
lhs = TREE_TYPE (lhs);
rhs = TREE_TYPE (rhs);
}
}
if (TREE_CODE (lhs) != RECORD_TYPE || TREE_CODE (rhs) != RECORD_TYPE)
{
/* Nothing to do with ObjC - let immediately comptypes take
responsibility for checking. */
return -1;
}
/* `id' = `<class> *' `<class> *' = `id': always allow it.
Please note that
'Object *o = [[Object alloc] init]; falls
in the case <class> * = `id'.
*/
if ((TYPE_NAME (lhs) == objc_object_id && TYPED_OBJECT (rhs))
|| (TYPE_NAME (rhs) == objc_object_id && TYPED_OBJECT (lhs)))
return 1;
/* `id' = `Class', `Class' = `id' */
else if ((TYPE_NAME (lhs) == objc_object_id
&& TYPE_NAME (rhs) == objc_class_id)
|| (TYPE_NAME (lhs) == objc_class_id
&& TYPE_NAME (rhs) == objc_object_id))
return 1;
/* `<class> *' = `<class> *' */
else if (TYPED_OBJECT (lhs) && TYPED_OBJECT (rhs))
{
tree lname = TYPE_NAME (lhs);
tree rname = TYPE_NAME (rhs);
tree inter;
if (lname == rname)
return 1;
/* If the left hand side is a super class of the right hand side,
allow it. */
for (inter = lookup_interface (rname); inter;
inter = lookup_interface (CLASS_SUPER_NAME (inter)))
if (lname == CLASS_SUPER_NAME (inter))
return 1;
/* Allow the reverse when reflexive. */
if (reflexive)
for (inter = lookup_interface (lname); inter;
inter = lookup_interface (CLASS_SUPER_NAME (inter)))
if (rname == CLASS_SUPER_NAME (inter))
return 1;
return 0;
}
else
/* Not an ObjC type - let comptypes do the check. */
return -1;
}
/* Called from c-decl.c before all calls to rest_of_decl_compilation. */
void
objc_check_decl (decl)
tree decl;
{
tree type = TREE_TYPE (decl);
if (TREE_CODE (type) == RECORD_TYPE
&& TREE_STATIC_TEMPLATE (type)
&& type != constant_string_type)
error_with_decl (decl, "`%s' cannot be statically allocated");
}
/* Implement static typing. At this point, we know we have an interface. */
tree
get_static_reference (interface, protocols)
tree interface;
tree protocols;
{
tree type = xref_tag (RECORD_TYPE, interface);
if (protocols)
{
tree t, m = TYPE_MAIN_VARIANT (type);
t = copy_node (type);
/* Add this type to the chain of variants of TYPE. */
TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
TYPE_NEXT_VARIANT (m) = t;
/* Look up protocols and install in lang specific list. Note
that the protocol list can have a different lifetime than T! */
TYPE_PROTOCOL_LIST (t) = lookup_and_install_protocols (protocols);
/* This forces a new pointer type to be created later
(in build_pointer_type)...so that the new template
we just created will actually be used...what a hack! */
if (TYPE_POINTER_TO (t))
TYPE_POINTER_TO (t) = NULL_TREE;
type = t;
}
return type;
}
tree
get_object_reference (protocols)
tree protocols;
{
tree type_decl = lookup_name (objc_id_id);
tree type;
if (type_decl && TREE_CODE (type_decl) == TYPE_DECL)
{
type = TREE_TYPE (type_decl);
if (TYPE_MAIN_VARIANT (type) != id_type)
warning ("unexpected type for `id' (%s)",
gen_declaration (type, errbuf));
}
else
{
error ("undefined type `id', please import <objc/objc.h>");
return error_mark_node;
}
/* This clause creates a new pointer type that is qualified with
the protocol specification...this info is used later to do more
elaborate type checking. */
if (protocols)
{
tree t, m = TYPE_MAIN_VARIANT (type);
t = copy_node (type);
/* Add this type to the chain of variants of TYPE. */
TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
TYPE_NEXT_VARIANT (m) = t;
/* Look up protocols...and install in lang specific list */
TYPE_PROTOCOL_LIST (t) = lookup_and_install_protocols (protocols);
/* This forces a new pointer type to be created later
(in build_pointer_type)...so that the new template
we just created will actually be used...what a hack! */
if (TYPE_POINTER_TO (t))
TYPE_POINTER_TO (t) = NULL_TREE;
type = t;
}
return type;
}
/* Check for circular dependencies in protocols. The arguments are
PROTO, the protocol to check, and LIST, a list of protocol it
conforms to. */
static void
check_protocol_recursively (proto, list)
tree proto;
tree list;
{
tree p;
for (p = list; p; p = TREE_CHAIN (p))
{
tree pp = TREE_VALUE (p);
if (TREE_CODE (pp) == IDENTIFIER_NODE)
pp = lookup_protocol (pp);
if (pp == proto)
fatal_error ("protocol `%s' has circular dependency",
IDENTIFIER_POINTER (PROTOCOL_NAME (pp)));
if (pp)
check_protocol_recursively (proto, PROTOCOL_LIST (pp));
}
}
static tree
lookup_and_install_protocols (protocols)
tree protocols;
{
tree proto;
tree prev = NULL;
tree return_value = protocols;
for (proto = protocols; proto; proto = TREE_CHAIN (proto))
{
tree ident = TREE_VALUE (proto);
tree p = lookup_protocol (ident);
if (!p)
{
error ("cannot find protocol declaration for `%s'",
IDENTIFIER_POINTER (ident));
if (prev)
TREE_CHAIN (prev) = TREE_CHAIN (proto);
else
return_value = TREE_CHAIN (proto);
}
else
{
/* Replace identifier with actual protocol node. */
TREE_VALUE (proto) = p;
prev = proto;
}
}
return return_value;
}
/* Create and push a decl for a built-in external variable or field NAME.
CODE says which.
TYPE is its data type. */
static tree
create_builtin_decl (code, type, name)
enum tree_code code;
tree type;
const char *name;
{
tree decl = build_decl (code, get_identifier (name), type);
if (code == VAR_DECL)
{
TREE_STATIC (decl) = 1;
make_decl_rtl (decl, 0);
pushdecl (decl);
}
DECL_ARTIFICIAL (decl) = 1;
return decl;
}
/* Find the decl for the constant string class. */
static void
setup_string_decl ()
{
if (!string_class_decl)
{
if (!constant_string_global_id)
constant_string_global_id = get_identifier (STRING_OBJECT_GLOBAL_NAME);
string_class_decl = lookup_name (constant_string_global_id);
}
}
/* Purpose: "play" parser, creating/installing representations
of the declarations that are required by Objective-C.
Model:
type_spec--------->sc_spec
(tree_list) (tree_list)
| |
| |
identifier_node identifier_node */
static void
synth_module_prologue ()
{
tree temp_type;
tree super_p;
/* Defined in `objc.h' */
objc_object_id = get_identifier (TAG_OBJECT);
objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
id_type = build_pointer_type (objc_object_reference);
objc_id_id = get_identifier (TYPE_ID);
objc_class_id = get_identifier (TAG_CLASS);
objc_class_type = build_pointer_type (xref_tag (RECORD_TYPE, objc_class_id));
protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (PROTOCOL_OBJECT_CLASS_NAME)));
/* Declare type of selector-objects that represent an operation name. */
/* `struct objc_selector *' */
selector_type
= build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)));
/* Forward declare type, or else the prototype for msgSendSuper will
complain. */
super_p = build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (TAG_SUPER)));
/* id objc_msgSend (id, SEL, ...); */
temp_type
= build_function_type (id_type,
tree_cons (NULL_TREE, id_type,
tree_cons (NULL_TREE, selector_type,
NULL_TREE)));
if (! flag_next_runtime)
{
umsg_decl = build_decl (FUNCTION_DECL,
get_identifier (TAG_MSGSEND), temp_type);
DECL_EXTERNAL (umsg_decl) = 1;
TREE_PUBLIC (umsg_decl) = 1;
DECL_INLINE (umsg_decl) = 1;
DECL_ARTIFICIAL (umsg_decl) = 1;
make_decl_rtl (umsg_decl, NULL);
pushdecl (umsg_decl);
}
else
umsg_decl = builtin_function (TAG_MSGSEND, temp_type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
/* id objc_msgSendSuper (struct objc_super *, SEL, ...); */
temp_type
= build_function_type (id_type,
tree_cons (NULL_TREE, super_p,
tree_cons (NULL_TREE, selector_type,
NULL_TREE)));
umsg_super_decl = builtin_function (TAG_MSGSENDSUPER,
temp_type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
/* id objc_getClass (const char *); */
temp_type = build_function_type (id_type,
tree_cons (NULL_TREE,
const_string_type_node,
tree_cons (NULL_TREE, void_type_node,
NULL_TREE)));
objc_get_class_decl
= builtin_function (TAG_GETCLASS, temp_type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
/* id objc_getMetaClass (const char *); */
objc_get_meta_class_decl
= builtin_function (TAG_GETMETACLASS, temp_type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
/* static SEL _OBJC_SELECTOR_TABLE[]; */
if (! flag_next_runtime)
{
if (flag_typed_selectors)
{
/* Suppress outputting debug symbols, because
dbxout_init hasn'r been called yet. */
enum debug_info_type save_write_symbols = write_symbols;
const struct gcc_debug_hooks *const save_hooks = debug_hooks;
write_symbols = NO_DEBUG;
debug_hooks = &do_nothing_debug_hooks;
build_selector_template ();
temp_type = build_array_type (objc_selector_template, NULL_TREE);
write_symbols = save_write_symbols;
debug_hooks = save_hooks;
}
else
temp_type = build_array_type (selector_type, NULL_TREE);
layout_type (temp_type);
UOBJC_SELECTOR_TABLE_decl
= create_builtin_decl (VAR_DECL, temp_type,
"_OBJC_SELECTOR_TABLE");
/* Avoid warning when not sending messages. */
TREE_USED (UOBJC_SELECTOR_TABLE_decl) = 1;
}
generate_forward_declaration_to_string_table ();
/* Forward declare constant_string_id and constant_string_type. */
if (!constant_string_class_name)
constant_string_class_name = default_constant_string_class_name;
constant_string_id = get_identifier (constant_string_class_name);
constant_string_type = xref_tag (RECORD_TYPE, constant_string_id);
}
/* Predefine the following data type:
struct STRING_OBJECT_CLASS_NAME
{
Object isa;
char *cString;
unsigned int length;
}; */
static void
build_string_class_template ()
{
tree field_decl, field_decl_chain;
field_decl = create_builtin_decl (FIELD_DECL, id_type, "isa");
field_decl_chain = field_decl;
field_decl = create_builtin_decl (FIELD_DECL,
build_pointer_type (char_type_node),
"cString");
chainon (field_decl_chain, field_decl);
field_decl = create_builtin_decl (FIELD_DECL, unsigned_type_node, "length");
chainon (field_decl_chain, field_decl);
finish_struct (constant_string_type, field_decl_chain, NULL_TREE);
}
/* Custom build_string which sets TREE_TYPE! */
static tree
my_build_string (len, str)
int len;
const char *str;
{
return fix_string_type (build_string (len, str));
}
/* Given a chain of STRING_CST's, build a static instance of
NXConstantString which points at the concatenation of those strings.
We place the string object in the __string_objects section of the
__OBJC segment. The Objective-C runtime will initialize the isa
pointers of the string objects to point at the NXConstantString
class object. */
tree
build_objc_string_object (strings)
tree strings;
{
tree string, initlist, constructor;
int length;
if (lookup_interface (constant_string_id) == NULL_TREE)
{
error ("cannot find interface declaration for `%s'",
IDENTIFIER_POINTER (constant_string_id));
return error_mark_node;
}
add_class_reference (constant_string_id);
if (TREE_CHAIN (strings))
{
varray_type vstrings;
VARRAY_TREE_INIT (vstrings, 32, "strings");
for (; strings ; strings = TREE_CHAIN (strings))
VARRAY_PUSH_TREE (vstrings, strings);
string = combine_strings (vstrings);
}
else
string = strings;
string = fix_string_type (string);
TREE_SET_CODE (string, STRING_CST);
length = TREE_STRING_LENGTH (string) - 1;
/* We could not properly create NXConstantString in synth_module_prologue,
because that's called before debugging is initialized. Do it now. */
if (TYPE_FIELDS (constant_string_type) == NULL_TREE)
build_string_class_template ();
/* & ((NXConstantString) { NULL, string, length }) */
if (flag_next_runtime)
{
/* For the NeXT runtime, we can generate a literal reference
to the string class, don't need to run a constructor. */
setup_string_decl ();
if (string_class_decl == NULL_TREE)
{
error ("cannot find reference tag for class `%s'",
IDENTIFIER_POINTER (constant_string_id));
return error_mark_node;
}
initlist = build_tree_list
(NULL_TREE,
copy_node (build_unary_op (ADDR_EXPR, string_class_decl, 0)));
}
else
{
initlist = build_tree_list (NULL_TREE, build_int_2 (0, 0));
}
initlist
= tree_cons (NULL_TREE, copy_node (build_unary_op (ADDR_EXPR, string, 1)),
initlist);
initlist = tree_cons (NULL_TREE, build_int_2 (length, 0), initlist);
constructor = build_constructor (constant_string_type, nreverse (initlist));
if (!flag_next_runtime)
{
constructor
= objc_add_static_instance (constructor, constant_string_type);
}
return (build_unary_op (ADDR_EXPR, constructor, 1));
}
/* Declare a static instance of CLASS_DECL initialized by CONSTRUCTOR. */
static tree
objc_add_static_instance (constructor, class_decl)
tree constructor, class_decl;
{
static int num_static_inst;
tree *chain, decl;
char buf[256];
/* Find the list of static instances for the CLASS_DECL. Create one if
not found. */
for (chain = &objc_static_instances;
*chain && TREE_VALUE (*chain) != class_decl;
chain = &TREE_CHAIN (*chain));
if (!*chain)
{
*chain = tree_cons (NULL_TREE, class_decl, NULL_TREE);
add_objc_string (TYPE_NAME (class_decl), class_names);
}
sprintf (buf, "_OBJC_INSTANCE_%d", num_static_inst++);
decl = build_decl (VAR_DECL, get_identifier (buf), class_decl);
DECL_COMMON (decl) = 1;
TREE_STATIC (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
DECL_INITIAL (decl) = constructor;
/* We may be writing something else just now.
Postpone till end of input. */
DECL_DEFER_OUTPUT (decl) = 1;
pushdecl_top_level (decl);
rest_of_decl_compilation (decl, 0, 1, 0);
/* Add the DECL to the head of this CLASS' list. */
TREE_PURPOSE (*chain) = tree_cons (NULL_TREE, decl, TREE_PURPOSE (*chain));
return decl;
}
/* Build a static constant CONSTRUCTOR
with type TYPE and elements ELTS. */
static tree
build_constructor (type, elts)
tree type, elts;
{
tree constructor, f, e;
/* ??? Most of the places that we build constructors, we don't fill in
the type of integers properly. Convert them all en masse. */
if (TREE_CODE (type) == ARRAY_TYPE)
{
f = TREE_TYPE (type);
if (TREE_CODE (f) == POINTER_TYPE || TREE_CODE (f) == INTEGER_TYPE)
for (e = elts; e ; e = TREE_CHAIN (e))
TREE_VALUE (e) = convert (f, TREE_VALUE (e));
}
else
{
f = TYPE_FIELDS (type);
for (e = elts; e && f; e = TREE_CHAIN (e), f = TREE_CHAIN (f))
if (TREE_CODE (TREE_TYPE (f)) == POINTER_TYPE
|| TREE_CODE (TREE_TYPE (f)) == INTEGER_TYPE)
TREE_VALUE (e) = convert (TREE_TYPE (f), TREE_VALUE (e));
}
constructor = build (CONSTRUCTOR, type, NULL_TREE, elts);
TREE_CONSTANT (constructor) = 1;
TREE_STATIC (constructor) = 1;
TREE_READONLY (constructor) = 1;
return constructor;
}
/* Take care of defining and initializing _OBJC_SYMBOLS. */
/* Predefine the following data type:
struct _objc_symtab
{
long sel_ref_cnt;
SEL *refs;
short cls_def_cnt;
short cat_def_cnt;
void *defs[cls_def_cnt + cat_def_cnt];
}; */
static void
build_objc_symtab_template ()
{
tree field_decl, field_decl_chain, index;
objc_symtab_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_SYMTAB));
/* long sel_ref_cnt; */
field_decl = create_builtin_decl (FIELD_DECL,
long_integer_type_node,
"sel_ref_cnt");
field_decl_chain = field_decl;
/* SEL *refs; */
field_decl = create_builtin_decl (FIELD_DECL,
build_pointer_type (selector_type),
"refs");
chainon (field_decl_chain, field_decl);
/* short cls_def_cnt; */
field_decl = create_builtin_decl (FIELD_DECL,
short_integer_type_node,
"cls_def_cnt");
chainon (field_decl_chain, field_decl);
/* short cat_def_cnt; */
field_decl = create_builtin_decl (FIELD_DECL,
short_integer_type_node,
"cat_def_cnt");
chainon (field_decl_chain, field_decl);
/* void *defs[cls_def_cnt + cat_def_cnt]; */
if (!flag_next_runtime)
index = build_index_type (build_int_2 (imp_count + cat_count, 0));
else
index = build_index_type (build_int_2 (imp_count + cat_count - 1,
imp_count == 0 && cat_count == 0
? -1 : 0));
field_decl = create_builtin_decl (FIELD_DECL,
build_array_type (ptr_type_node, index),
"defs");
chainon (field_decl_chain, field_decl);
finish_struct (objc_symtab_template, field_decl_chain, NULL_TREE);
}
/* Create the initial value for the `defs' field of _objc_symtab.
This is a CONSTRUCTOR. */
static tree
init_def_list (type)
tree type;
{
tree expr, initlist = NULL_TREE;
struct imp_entry *impent;
if (imp_count)
for (impent = imp_list; impent; impent = impent->next)
{
if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
{
expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (cat_count)
for (impent = imp_list; impent; impent = impent->next)
{
if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (!flag_next_runtime)
{
/* statics = { ..., _OBJC_STATIC_INSTANCES, ... } */
tree expr;
if (static_instances_decl)
expr = build_unary_op (ADDR_EXPR, static_instances_decl, 0);
else
expr = build_int_2 (0, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
return build_constructor (type, nreverse (initlist));
}
/* Construct the initial value for all of _objc_symtab. */
static tree
init_objc_symtab (type)
tree type;
{
tree initlist;
/* sel_ref_cnt = { ..., 5, ... } */
initlist = build_tree_list (NULL_TREE, build_int_2 (0, 0));
/* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */
if (flag_next_runtime || ! sel_ref_chain)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
initlist = tree_cons (NULL_TREE,
build_unary_op (ADDR_EXPR,
UOBJC_SELECTOR_TABLE_decl, 1),
initlist);
/* cls_def_cnt = { ..., 5, ... } */
initlist = tree_cons (NULL_TREE, build_int_2 (imp_count, 0), initlist);
/* cat_def_cnt = { ..., 5, ... } */
initlist = tree_cons (NULL_TREE, build_int_2 (cat_count, 0), initlist);
/* cls_def = { ..., { &Foo, &Bar, ...}, ... } */
if (imp_count || cat_count || static_instances_decl)
{
tree field = TYPE_FIELDS (type);
field = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (field))));
initlist = tree_cons (NULL_TREE, init_def_list (TREE_TYPE (field)),
initlist);
}
return build_constructor (type, nreverse (initlist));
}
/* Push forward-declarations of all the categories so that
init_def_list can use them in a CONSTRUCTOR. */
static void
forward_declare_categories ()
{
struct imp_entry *impent;
tree sav = objc_implementation_context;
for (impent = imp_list; impent; impent = impent->next)
{
if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
/* Set an invisible arg to synth_id_with_class_suffix. */
objc_implementation_context = impent->imp_context;
impent->class_decl
= create_builtin_decl (VAR_DECL, objc_category_template,
IDENTIFIER_POINTER (synth_id_with_class_suffix ("_OBJC_CATEGORY", objc_implementation_context)));
}
}
objc_implementation_context = sav;
}
/* Create the declaration of _OBJC_SYMBOLS, with type `strict _objc_symtab'
and initialized appropriately. */
static void
generate_objc_symtab_decl ()
{
tree sc_spec;
if (!objc_category_template)
build_category_template ();
/* forward declare categories */
if (cat_count)
forward_declare_categories ();
if (!objc_symtab_template)
build_objc_symtab_template ();
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
UOBJC_SYMBOLS_decl = start_decl (get_identifier ("_OBJC_SYMBOLS"),
tree_cons (NULL_TREE,
objc_symtab_template, sc_spec),
1,
NULL_TREE);
TREE_USED (UOBJC_SYMBOLS_decl) = 1;
DECL_IGNORED_P (UOBJC_SYMBOLS_decl) = 1;
DECL_ARTIFICIAL (UOBJC_SYMBOLS_decl) = 1;
finish_decl (UOBJC_SYMBOLS_decl,
init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl)),
NULL_TREE);
}
static tree
init_module_descriptor (type)
tree type;
{
tree initlist, expr;
/* version = { 1, ... } */
expr = build_int_2 (OBJC_VERSION, 0);
initlist = build_tree_list (NULL_TREE, expr);
/* size = { ..., sizeof (struct objc_module), ... } */
expr = size_in_bytes (objc_module_template);
initlist = tree_cons (NULL_TREE, expr, initlist);
/* name = { ..., "foo.m", ... } */
expr = add_objc_string (get_identifier (input_filename), class_names);
initlist = tree_cons (NULL_TREE, expr, initlist);
/* symtab = { ..., _OBJC_SYMBOLS, ... } */
if (UOBJC_SYMBOLS_decl)
expr = build_unary_op (ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
else
expr = build_int_2 (0, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
return build_constructor (type, nreverse (initlist));
}
/* Write out the data structures to describe Objective C classes defined.
If appropriate, compile and output a setup function to initialize them.
Return a symbol_ref to the function to call to initialize the Objective C
data structures for this file (and perhaps for other files also).
struct objc_module { ... } _OBJC_MODULE = { ... }; */
static rtx
build_module_descriptor ()
{
tree decl_specs, field_decl, field_decl_chain;
objc_module_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_MODULE));
/* Long version; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
field_decl = get_identifier ("version");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
/* long size; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
field_decl = get_identifier ("size");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* char *name; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("name"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_symtab *symtab; */
decl_specs = get_identifier (UTAG_SYMTAB);
decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE, decl_specs));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("symtab"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
finish_struct (objc_module_template, field_decl_chain, NULL_TREE);
/* Create an instance of "objc_module". */
decl_specs = tree_cons (NULL_TREE, objc_module_template,
build_tree_list (NULL_TREE,
ridpointers[(int) RID_STATIC]));
UOBJC_MODULES_decl = start_decl (get_identifier ("_OBJC_MODULES"),
decl_specs, 1, NULL_TREE);
DECL_ARTIFICIAL (UOBJC_MODULES_decl) = 1;
DECL_IGNORED_P (UOBJC_MODULES_decl) = 1;
DECL_CONTEXT (UOBJC_MODULES_decl) = NULL_TREE;
finish_decl (UOBJC_MODULES_decl,
init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl)),
NULL_TREE);
/* Mark the decl to avoid "defined but not used" warning. */
DECL_IN_SYSTEM_HEADER (UOBJC_MODULES_decl) = 1;
/* Generate a constructor call for the module descriptor.
This code was generated by reading the grammar rules
of c-parse.in; Therefore, it may not be the most efficient
way of generating the requisite code. */
if (flag_next_runtime)
return NULL_RTX;
{
tree parms, execclass_decl, decelerator, void_list_node_1;
tree init_function_name, init_function_decl;
/* Declare void __objc_execClass (void *); */
void_list_node_1 = build_tree_list (NULL_TREE, void_type_node);
execclass_decl = build_decl (FUNCTION_DECL,
get_identifier (TAG_EXECCLASS),
build_function_type (void_type_node,
tree_cons (NULL_TREE, ptr_type_node,
void_list_node_1)));
DECL_EXTERNAL (execclass_decl) = 1;
DECL_ARTIFICIAL (execclass_decl) = 1;
TREE_PUBLIC (execclass_decl) = 1;
pushdecl (execclass_decl);
rest_of_decl_compilation (execclass_decl, 0, 0, 0);
assemble_external (execclass_decl);
/* void _GLOBAL_$I$<gnyf> () {objc_execClass (&L_OBJC_MODULES);} */
init_function_name = get_file_function_name ('I');
start_function (void_list_node_1,
build_nt (CALL_EXPR, init_function_name,
tree_cons (NULL_TREE, NULL_TREE,
void_list_node_1),
NULL_TREE),
NULL_TREE);
store_parm_decls ();
init_function_decl = current_function_decl;
TREE_PUBLIC (init_function_decl) = ! targetm.have_ctors_dtors;
TREE_USED (init_function_decl) = 1;
/* Don't let this one be deferred. */
DECL_INLINE (init_function_decl) = 0;
DECL_UNINLINABLE (init_function_decl) = 1;
current_function_cannot_inline
= "static constructors and destructors cannot be inlined";
parms
= build_tree_list (NULL_TREE,
build_unary_op (ADDR_EXPR, UOBJC_MODULES_decl, 0));
decelerator = build_function_call (execclass_decl, parms);
c_expand_expr_stmt (decelerator);
finish_function (0, 0);
return XEXP (DECL_RTL (init_function_decl), 0);
}
}
/* extern const char _OBJC_STRINGS[]; */
static void
generate_forward_declaration_to_string_table ()
{
tree sc_spec, decl_specs, expr_decl;
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_EXTERN], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
expr_decl
= build_nt (ARRAY_REF, get_identifier ("_OBJC_STRINGS"), NULL_TREE);
UOBJC_STRINGS_decl = define_decl (expr_decl, decl_specs);
}
/* Return the DECL of the string IDENT in the SECTION. */
static tree
get_objc_string_decl (ident, section)
tree ident;
enum string_section section;
{
tree chain;
if (section == class_names)
chain = class_names_chain;
else if (section == meth_var_names)
chain = meth_var_names_chain;
else if (section == meth_var_types)
chain = meth_var_types_chain;
else
abort ();
for (; chain != 0; chain = TREE_CHAIN (chain))
if (TREE_VALUE (chain) == ident)
return (TREE_PURPOSE (chain));
abort ();
return NULL_TREE;
}
/* Output references to all statically allocated objects. Return the DECL
for the array built. */
static void
generate_static_references ()
{
tree decls = NULL_TREE, ident, decl_spec, expr_decl, expr = NULL_TREE;
tree class_name, class, decl, initlist;
tree cl_chain, in_chain, type;
int num_inst, num_class;
char buf[256];
if (flag_next_runtime)
abort ();
for (cl_chain = objc_static_instances, num_class = 0;
cl_chain; cl_chain = TREE_CHAIN (cl_chain), num_class++)
{
for (num_inst = 0, in_chain = TREE_PURPOSE (cl_chain);
in_chain; num_inst++, in_chain = TREE_CHAIN (in_chain));
sprintf (buf, "_OBJC_STATIC_INSTANCES_%d", num_class);
ident = get_identifier (buf);
expr_decl = build_nt (ARRAY_REF, ident, NULL_TREE);
decl_spec = tree_cons (NULL_TREE, build_pointer_type (void_type_node),
build_tree_list (NULL_TREE,
ridpointers[(int) RID_STATIC]));
decl = start_decl (expr_decl, decl_spec, 1, NULL_TREE);
DECL_CONTEXT (decl) = 0;
DECL_ARTIFICIAL (decl) = 1;
/* Output {class_name, ...}. */
class = TREE_VALUE (cl_chain);
class_name = get_objc_string_decl (TYPE_NAME (class), class_names);
initlist = build_tree_list (NULL_TREE,
build_unary_op (ADDR_EXPR, class_name, 1));
/* Output {..., instance, ...}. */
for (in_chain = TREE_PURPOSE (cl_chain);
in_chain; in_chain = TREE_CHAIN (in_chain))
{
expr = build_unary_op (ADDR_EXPR, TREE_VALUE (in_chain), 1);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
/* Output {..., NULL}. */
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
expr = build_constructor (TREE_TYPE (decl), nreverse (initlist));
finish_decl (decl, expr, NULL_TREE);
TREE_USED (decl) = 1;
type = build_array_type (build_pointer_type (void_type_node), 0);
decl = build_decl (VAR_DECL, ident, type);
TREE_USED (decl) = 1;
TREE_STATIC (decl) = 1;
decls
= tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, decl, 1), decls);
}
decls = tree_cons (NULL_TREE, build_int_2 (0, 0), decls);
ident = get_identifier ("_OBJC_STATIC_INSTANCES");
expr_decl = build_nt (ARRAY_REF, ident, NULL_TREE);
decl_spec = tree_cons (NULL_TREE, build_pointer_type (void_type_node),
build_tree_list (NULL_TREE,
ridpointers[(int) RID_STATIC]));
static_instances_decl
= start_decl (expr_decl, decl_spec, 1, NULL_TREE);
TREE_USED (static_instances_decl) = 1;
DECL_CONTEXT (static_instances_decl) = 0;
DECL_ARTIFICIAL (static_instances_decl) = 1;
expr = build_constructor (TREE_TYPE (static_instances_decl),
nreverse (decls));
finish_decl (static_instances_decl, expr, NULL_TREE);
}
/* Output all strings. */
static void
generate_strings ()
{
tree sc_spec, decl_specs, expr_decl;
tree chain, string_expr;
tree string, decl;
for (chain = class_names_chain; chain; chain = TREE_CHAIN (chain))
{
string = TREE_VALUE (chain);
decl = TREE_PURPOSE (chain);
sc_spec
= tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULL_TREE);
decl = start_decl (expr_decl, decl_specs, 1, NULL_TREE);
DECL_CONTEXT (decl) = NULL_TREE;
string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
IDENTIFIER_POINTER (string));
finish_decl (decl, string_expr, NULL_TREE);
}
for (chain = meth_var_names_chain; chain; chain = TREE_CHAIN (chain))
{
string = TREE_VALUE (chain);
decl = TREE_PURPOSE (chain);
sc_spec
= tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULL_TREE);
decl = start_decl (expr_decl, decl_specs, 1, NULL_TREE);
DECL_CONTEXT (decl) = NULL_TREE;
string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
IDENTIFIER_POINTER (string));
finish_decl (decl, string_expr, NULL_TREE);
}
for (chain = meth_var_types_chain; chain; chain = TREE_CHAIN (chain))
{
string = TREE_VALUE (chain);
decl = TREE_PURPOSE (chain);
sc_spec
= tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULL_TREE);
decl = start_decl (expr_decl, decl_specs, 1, NULL_TREE);
DECL_CONTEXT (decl) = NULL_TREE;
string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
IDENTIFIER_POINTER (string));
finish_decl (decl, string_expr, NULL_TREE);
}
}
static tree
build_selector_reference_decl ()
{
tree decl, ident;
char buf[256];
static int idx = 0;
sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", idx++);
ident = get_identifier (buf);
decl = build_decl (VAR_DECL, ident, selector_type);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
TREE_USED (decl) = 1;
TREE_READONLY (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
DECL_CONTEXT (decl) = 0;
make_decl_rtl (decl, 0);
pushdecl_top_level (decl);
return decl;
}
/* Just a handy wrapper for add_objc_string. */
static tree
build_selector (ident)
tree ident;
{
tree expr = add_objc_string (ident, meth_var_names);
if (flag_typed_selectors)
return expr;
else
return build_c_cast (selector_type, expr); /* cast! */
}
static void
build_selector_translation_table ()
{
tree sc_spec, decl_specs;
tree chain, initlist = NULL_TREE;
int offset = 0;
tree decl = NULL_TREE, var_decl, name;
for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
{
tree expr;
if (warn_selector && objc_implementation_context)
{
tree method_chain;
bool found = false;
for (method_chain = meth_var_names_chain;
method_chain;
method_chain = TREE_CHAIN (method_chain))
{
if (TREE_VALUE (method_chain) == TREE_VALUE (chain))
{
found = true;
break;
}
}
if (!found)
{
/* Adjust line number for warning message. */
int save_lineno = lineno;
if (flag_next_runtime && TREE_PURPOSE (chain))
lineno = DECL_SOURCE_LINE (TREE_PURPOSE (chain));
warning ("creating selector for non existant method %s",
IDENTIFIER_POINTER (TREE_VALUE (chain)));
lineno = save_lineno;
}
}
expr = build_selector (TREE_VALUE (chain));
if (flag_next_runtime)
{
name = DECL_NAME (TREE_PURPOSE (chain));
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
/* static SEL _OBJC_SELECTOR_REFERENCES_n = ...; */
decl_specs = tree_cons (NULL_TREE, selector_type, sc_spec);
var_decl = name;
/* The `decl' that is returned from start_decl is the one that we
forward declared in `build_selector_reference' */
decl = start_decl (var_decl, decl_specs, 1, NULL_TREE );
}
/* add one for the '\0' character */
offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1;
if (flag_next_runtime)
finish_decl (decl, expr, NULL_TREE);
else
{
if (flag_typed_selectors)
{
tree eltlist = NULL_TREE;
tree encoding = get_proto_encoding (TREE_PURPOSE (chain));
eltlist = tree_cons (NULL_TREE, expr, NULL_TREE);
eltlist = tree_cons (NULL_TREE, encoding, eltlist);
expr = build_constructor (objc_selector_template,
nreverse (eltlist));
}
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (! flag_next_runtime)
{
/* Cause the variable and its initial value to be actually output. */
DECL_EXTERNAL (UOBJC_SELECTOR_TABLE_decl) = 0;
TREE_STATIC (UOBJC_SELECTOR_TABLE_decl) = 1;
/* NULL terminate the list and fix the decl for output. */
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
DECL_INITIAL (UOBJC_SELECTOR_TABLE_decl) = objc_ellipsis_node;
initlist = build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl),
nreverse (initlist));
finish_decl (UOBJC_SELECTOR_TABLE_decl, initlist, NULL_TREE);
current_function_decl = NULL_TREE;
}
}
static tree
get_proto_encoding (proto)
tree proto;
{
tree encoding;
if (proto)
{
tree tmp_decl;
if (! METHOD_ENCODING (proto))
{
tmp_decl = build_tmp_function_decl ();
hack_method_prototype (proto, tmp_decl);
encoding = encode_method_prototype (proto, tmp_decl);
METHOD_ENCODING (proto) = encoding;
}
else
encoding = METHOD_ENCODING (proto);
return add_objc_string (encoding, meth_var_types);
}
else
return build_int_2 (0, 0);
}
/* sel_ref_chain is a list whose "value" fields will be instances of
identifier_node that represent the selector. */
static tree
build_typed_selector_reference (ident, prototype)
tree ident, prototype;
{
tree *chain = &sel_ref_chain;
tree expr;
int index = 0;
while (*chain)
{
if (TREE_PURPOSE (*chain) == prototype && TREE_VALUE (*chain) == ident)
goto return_at_index;
index++;
chain = &TREE_CHAIN (*chain);
}
*chain = tree_cons (prototype, ident, NULL_TREE);
return_at_index:
expr = build_unary_op (ADDR_EXPR,
build_array_ref (UOBJC_SELECTOR_TABLE_decl,
build_int_2 (index, 0)),
1);
return build_c_cast (selector_type, expr);
}
static tree
build_selector_reference (ident)
tree ident;
{
tree *chain = &sel_ref_chain;
tree expr;
int index = 0;
while (*chain)
{
if (TREE_VALUE (*chain) == ident)
return (flag_next_runtime
? TREE_PURPOSE (*chain)
: build_array_ref (UOBJC_SELECTOR_TABLE_decl,
build_int_2 (index, 0)));
index++;
chain = &TREE_CHAIN (*chain);
}
expr = build_selector_reference_decl ();
*chain = tree_cons (expr, ident, NULL_TREE);
return (flag_next_runtime
? expr
: build_array_ref (UOBJC_SELECTOR_TABLE_decl,
build_int_2 (index, 0)));
}
static tree
build_class_reference_decl ()
{
tree decl, ident;
char buf[256];
static int idx = 0;
sprintf (buf, "_OBJC_CLASS_REFERENCES_%d", idx++);
ident = get_identifier (buf);
decl = build_decl (VAR_DECL, ident, objc_class_type);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
TREE_USED (decl) = 1;
TREE_READONLY (decl) = 1;
DECL_CONTEXT (decl) = 0;
DECL_ARTIFICIAL (decl) = 1;
make_decl_rtl (decl, 0);
pushdecl_top_level (decl);
return decl;
}
/* Create a class reference, but don't create a variable to reference
it. */
static void
add_class_reference (ident)
tree ident;
{
tree chain;
if ((chain = cls_ref_chain))
{
tree tail;
do
{
if (ident == TREE_VALUE (chain))
return;
tail = chain;
chain = TREE_CHAIN (chain);
}
while (chain);
/* Append to the end of the list */
TREE_CHAIN (tail) = tree_cons (NULL_TREE, ident, NULL_TREE);
}
else
cls_ref_chain = tree_cons (NULL_TREE, ident, NULL_TREE);
}
/* Get a class reference, creating it if necessary. Also create the
reference variable. */
tree
get_class_reference (ident)
tree ident;
{
if (flag_next_runtime)
{
tree *chain;
tree decl;
for (chain = &cls_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
if (TREE_VALUE (*chain) == ident)
{
if (! TREE_PURPOSE (*chain))
TREE_PURPOSE (*chain) = build_class_reference_decl ();
return TREE_PURPOSE (*chain);
}
decl = build_class_reference_decl ();
*chain = tree_cons (decl, ident, NULL_TREE);
return decl;
}
else
{
tree params;
add_class_reference (ident);
params = build_tree_list (NULL_TREE,
my_build_string (IDENTIFIER_LENGTH (ident) + 1,
IDENTIFIER_POINTER (ident)));
assemble_external (objc_get_class_decl);
return build_function_call (objc_get_class_decl, params);
}
}
/* For each string section we have a chain which maps identifier nodes
to decls for the strings. */
static tree
add_objc_string (ident, section)
tree ident;
enum string_section section;
{
tree *chain, decl;
if (section == class_names)
chain = &class_names_chain;
else if (section == meth_var_names)
chain = &meth_var_names_chain;
else if (section == meth_var_types)
chain = &meth_var_types_chain;
else
abort ();
while (*chain)
{
if (TREE_VALUE (*chain) == ident)
return build_unary_op (ADDR_EXPR, TREE_PURPOSE (*chain), 1);
chain = &TREE_CHAIN (*chain);
}
decl = build_objc_string_decl (section);
*chain = tree_cons (decl, ident, NULL_TREE);
return build_unary_op (ADDR_EXPR, decl, 1);
}
static tree
build_objc_string_decl (section)
enum string_section section;
{
tree decl, ident;
char buf[256];
static int class_names_idx = 0;
static int meth_var_names_idx = 0;
static int meth_var_types_idx = 0;
if (section == class_names)
sprintf (buf, "_OBJC_CLASS_NAME_%d", class_names_idx++);
else if (section == meth_var_names)
sprintf (buf, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++);
else if (section == meth_var_types)
sprintf (buf, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++);
ident = get_identifier (buf);
decl = build_decl (VAR_DECL, ident, build_array_type (char_type_node, 0));
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
TREE_USED (decl) = 1;
TREE_READONLY (decl) = 1;
TREE_CONSTANT (decl) = 1;
DECL_CONTEXT (decl) = 0;
DECL_ARTIFICIAL (decl) = 1;
make_decl_rtl (decl, 0);
pushdecl_top_level (decl);
return decl;
}
void
objc_declare_alias (alias_ident, class_ident)
tree alias_ident;
tree class_ident;
{
if (is_class_name (class_ident) != class_ident)
warning ("cannot find class `%s'", IDENTIFIER_POINTER (class_ident));
else if (is_class_name (alias_ident))
warning ("class `%s' already exists", IDENTIFIER_POINTER (alias_ident));
else
alias_chain = tree_cons (class_ident, alias_ident, alias_chain);
}
void
objc_declare_class (ident_list)
tree ident_list;
{
tree list;
for (list = ident_list; list; list = TREE_CHAIN (list))
{
tree ident = TREE_VALUE (list);
tree decl;
if ((decl = lookup_name (ident)))
{
error ("`%s' redeclared as different kind of symbol",
IDENTIFIER_POINTER (ident));
error_with_decl (decl, "previous declaration of `%s'");
}
if (! is_class_name (ident))
{
tree record = xref_tag (RECORD_TYPE, ident);
TREE_STATIC_TEMPLATE (record) = 1;
class_chain = tree_cons (NULL_TREE, ident, class_chain);
}
}
}
tree
is_class_name (ident)
tree ident;
{
tree chain;
if (lookup_interface (ident))
return ident;
for (chain = class_chain; chain; chain = TREE_CHAIN (chain))
{
if (ident == TREE_VALUE (chain))
return ident;
}
for (chain = alias_chain; chain; chain = TREE_CHAIN (chain))
{
if (ident == TREE_VALUE (chain))
return TREE_PURPOSE (chain);
}
return 0;
}
tree
objc_is_id (ident)
tree ident;
{
/* NB: This function may be called before the ObjC front-end
has been initialized, in which case ID_TYPE will be NULL. */
return (id_type && ident && TYPE_P (ident) && IS_ID (ident))
? id_type
: NULL_TREE;
}
tree
lookup_interface (ident)
tree ident;
{
tree chain;
for (chain = interface_chain; chain; chain = TREE_CHAIN (chain))
{
if (ident == CLASS_NAME (chain))
return chain;
}
return NULL_TREE;
}
/* Used by: build_private_template, continue_class,
and for @defs constructs. */
tree
get_class_ivars (interface)
tree interface;
{
tree my_name, super_name, ivar_chain;
my_name = CLASS_NAME (interface);
super_name = CLASS_SUPER_NAME (interface);
ivar_chain = CLASS_IVARS (interface);
/* Save off a pristine copy of the leaf ivars (i.e, those not
inherited from a super class). */
if (!CLASS_OWN_IVARS (interface))
CLASS_OWN_IVARS (interface) = copy_list (ivar_chain);
while (super_name)
{
tree op1;
tree super_interface = lookup_interface (super_name);
if (!super_interface)
{
/* fatal did not work with 2 args...should fix */
error ("cannot find interface declaration for `%s', superclass of `%s'",
IDENTIFIER_POINTER (super_name),
IDENTIFIER_POINTER (my_name));
exit (FATAL_EXIT_CODE);
}
if (super_interface == interface)
fatal_error ("circular inheritance in interface declaration for `%s'",
IDENTIFIER_POINTER (super_name));
interface = super_interface;
my_name = CLASS_NAME (interface);
super_name = CLASS_SUPER_NAME (interface);
op1 = CLASS_OWN_IVARS (interface);
if (op1)
{
tree head = copy_list (op1);
/* Prepend super class ivars...make a copy of the list, we
do not want to alter the original. */
chainon (head, ivar_chain);
ivar_chain = head;
}
}
return ivar_chain;
}
/* struct <classname> {
struct objc_class *isa;
...
}; */
static tree
build_private_template (class)
tree class;
{
tree ivar_context;
if (CLASS_STATIC_TEMPLATE (class))
{
uprivate_record = CLASS_STATIC_TEMPLATE (class);
ivar_context = TYPE_FIELDS (CLASS_STATIC_TEMPLATE (class));
}
else
{
uprivate_record = start_struct (RECORD_TYPE, CLASS_NAME (class));
ivar_context = get_class_ivars (class);
finish_struct (uprivate_record, ivar_context, NULL_TREE);
CLASS_STATIC_TEMPLATE (class) = uprivate_record;
/* mark this record as class template - for class type checking */
TREE_STATIC_TEMPLATE (uprivate_record) = 1;
}
instance_type
= groktypename (build_tree_list (build_tree_list (NULL_TREE,
uprivate_record),
build1 (INDIRECT_REF, NULL_TREE,
NULL_TREE)));
return ivar_context;
}
/* Begin code generation for protocols... */
/* struct objc_protocol {
char *protocol_name;
struct objc_protocol **protocol_list;
struct objc_method_desc *instance_methods;
struct objc_method_desc *class_methods;
}; */
static tree
build_protocol_template ()
{
tree decl_specs, field_decl, field_decl_chain;
tree template;
template = start_struct (RECORD_TYPE, get_identifier (UTAG_PROTOCOL));
/* struct objc_class *isa; */
decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (UTAG_CLASS)));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("isa"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
/* char *protocol_name; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_name"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_protocol **protocol_list; */
decl_specs = build_tree_list (NULL_TREE, template);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_list"));
field_decl = build1 (INDIRECT_REF, NULL_TREE, field_decl);
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_method_list *instance_methods; */
decl_specs
= build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("instance_methods"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_method_list *class_methods; */
decl_specs
= build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class_methods"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
return finish_struct (template, field_decl_chain, NULL_TREE);
}
static tree
build_descriptor_table_initializer (type, entries)
tree type;
tree entries;
{
tree initlist = NULL_TREE;
do
{
tree eltlist = NULL_TREE;
eltlist
= tree_cons (NULL_TREE,
build_selector (METHOD_SEL_NAME (entries)), NULL_TREE);
eltlist
= tree_cons (NULL_TREE,
add_objc_string (METHOD_ENCODING (entries),
meth_var_types),
eltlist);
initlist
= tree_cons (NULL_TREE,
build_constructor (type, nreverse (eltlist)), initlist);
entries = TREE_CHAIN (entries);
}
while (entries);
return build_constructor (build_array_type (type, 0), nreverse (initlist));
}
/* struct objc_method_prototype_list {
int count;
struct objc_method_prototype {
SEL name;
char *types;
} list[1];
}; */
static tree
build_method_prototype_list_template (list_type, size)
tree list_type;
int size;
{
tree objc_ivar_list_record;
tree decl_specs, field_decl, field_decl_chain;
/* Generate an unnamed struct definition. */
objc_ivar_list_record = start_struct (RECORD_TYPE, NULL_TREE);
/* int method_count; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
field_decl = get_identifier ("method_count");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
/* struct objc_method method_list[]; */
decl_specs = build_tree_list (NULL_TREE, list_type);
field_decl = build_nt (ARRAY_REF, get_identifier ("method_list"),
build_int_2 (size, 0));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
finish_struct (objc_ivar_list_record, field_decl_chain, NULL_TREE);
return objc_ivar_list_record;
}
static tree
build_method_prototype_template ()
{
tree proto_record;
tree decl_specs, field_decl, field_decl_chain;
proto_record
= start_struct (RECORD_TYPE, get_identifier (UTAG_METHOD_PROTOTYPE));
/* struct objc_selector *_cmd; */
decl_specs = tree_cons (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)), NULL_TREE);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("_cmd"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], NULL_TREE);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("method_types"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
finish_struct (proto_record, field_decl_chain, NULL_TREE);
return proto_record;
}
/* True if last call to forwarding_offset yielded a register offset. */
static int offset_is_register;
static int
forwarding_offset (parm)
tree parm;
{
int offset_in_bytes;
if (GET_CODE (DECL_INCOMING_RTL (parm)) == MEM)
{
rtx addr = XEXP (DECL_INCOMING_RTL (parm), 0);
/* ??? Here we assume that the parm address is indexed
off the frame pointer or arg pointer.
If that is not true, we produce meaningless results,
but do not crash. */
if (GET_CODE (addr) == PLUS
&& GET_CODE (XEXP (addr, 1)) == CONST_INT)
offset_in_bytes = INTVAL (XEXP (addr, 1));
else
offset_in_bytes = 0;
offset_in_bytes += OBJC_FORWARDING_STACK_OFFSET;
offset_is_register = 0;
}
else if (GET_CODE (DECL_INCOMING_RTL (parm)) == REG)
{
int regno = REGNO (DECL_INCOMING_RTL (parm));
offset_in_bytes = apply_args_register_offset (regno);
offset_is_register = 1;
}
else
return 0;
/* This is the case where the parm is passed as an int or double
and it is converted to a char, short or float and stored back
in the parmlist. In this case, describe the parm
with the variable's declared type, and adjust the address
if the least significant bytes (which we are using) are not
the first ones. */
if (BYTES_BIG_ENDIAN && TREE_TYPE (parm) != DECL_ARG_TYPE (parm))
offset_in_bytes += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parm)))
- GET_MODE_SIZE (GET_MODE (DECL_RTL (parm))));
return offset_in_bytes;
}
static tree
encode_method_prototype (method_decl, func_decl)
tree method_decl;
tree func_decl;
{
tree parms;
int stack_size, i;
tree user_args;
HOST_WIDE_INT max_parm_end = 0;
char buf[40];
tree result;
/* ONEWAY and BYCOPY, for remote object are the only method qualifiers. */
encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (method_decl)));
/* C type. */
encode_type (TREE_TYPE (TREE_TYPE (func_decl)),
obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
/* Stack size. */
for (parms = DECL_ARGUMENTS (func_decl); parms;
parms = TREE_CHAIN (parms))
{
HOST_WIDE_INT parm_end = (forwarding_offset (parms)
+ int_size_in_bytes (TREE_TYPE (parms)));
if (!offset_is_register && max_parm_end < parm_end)
max_parm_end = parm_end;
}
stack_size = max_parm_end - OBJC_FORWARDING_MIN_OFFSET;
sprintf (buf, "%d", stack_size);
obstack_grow (&util_obstack, buf, strlen (buf));
user_args = METHOD_SEL_ARGS (method_decl);
/* Argument types. */
for (parms = DECL_ARGUMENTS (func_decl), i = 0; parms;
parms = TREE_CHAIN (parms), i++)
{
/* Process argument qualifiers for user supplied arguments. */
if (i > 1)
{
encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (user_args)));
user_args = TREE_CHAIN (user_args);
}
/* Type. */
encode_type (TREE_TYPE (parms),
obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
/* Compute offset. */
sprintf (buf, "%d", forwarding_offset (parms));
/* Indicate register. */
if (offset_is_register)
obstack_1grow (&util_obstack, '+');
obstack_grow (&util_obstack, buf, strlen (buf));
}
obstack_1grow (&util_obstack, '\0');
result = get_identifier (obstack_finish (&util_obstack));
obstack_free (&util_obstack, util_firstobj);
return result;
}
static tree
generate_descriptor_table (type, name, size, list, proto)
tree type;
const char *name;
int size;
tree list;
tree proto;
{
tree sc_spec, decl_specs, decl, initlist;
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, type, sc_spec);
decl = start_decl (synth_id_with_class_suffix (name, proto),
decl_specs, 1, NULL_TREE);
DECL_CONTEXT (decl) = NULL_TREE;
initlist = build_tree_list (NULL_TREE, build_int_2 (size, 0));
initlist = tree_cons (NULL_TREE, list, initlist);
finish_decl (decl, build_constructor (type, nreverse (initlist)),
NULL_TREE);
return decl;
}
static void
generate_method_descriptors (protocol)
tree protocol;
{
tree initlist, chain, method_list_template;
tree cast, variable_length_type;
int size;
if (!objc_method_prototype_template)
objc_method_prototype_template = build_method_prototype_template ();
cast = build_tree_list (build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_PROTOTYPE_LIST))),
NULL_TREE);
variable_length_type = groktypename (cast);
chain = PROTOCOL_CLS_METHODS (protocol);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_prototype_list_template (objc_method_prototype_template,
size);
initlist
= build_descriptor_table_initializer (objc_method_prototype_template,
chain);
UOBJC_CLASS_METHODS_decl
= generate_descriptor_table (method_list_template,
"_OBJC_PROTOCOL_CLASS_METHODS",
size, initlist, protocol);
TREE_TYPE (UOBJC_CLASS_METHODS_decl) = variable_length_type;
}
else
UOBJC_CLASS_METHODS_decl = 0;
chain = PROTOCOL_NST_METHODS (protocol);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_prototype_list_template (objc_method_prototype_template,
size);
initlist
= build_descriptor_table_initializer (objc_method_prototype_template,
chain);
UOBJC_INSTANCE_METHODS_decl
= generate_descriptor_table (method_list_template,
"_OBJC_PROTOCOL_INSTANCE_METHODS",
size, initlist, protocol);
TREE_TYPE (UOBJC_INSTANCE_METHODS_decl) = variable_length_type;
}
else
UOBJC_INSTANCE_METHODS_decl = 0;
}
/* Generate a temporary FUNCTION_DECL node to be used in
hack_method_prototype below. */
static tree
build_tmp_function_decl ()
{
tree decl_specs, expr_decl, parms;
static int xxx = 0;
char buffer[80];
/* struct objc_object *objc_xxx (id, SEL, ...); */
pushlevel (0);
decl_specs = build_tree_list (NULL_TREE, objc_object_reference);
push_parm_decl (build_tree_list
(build_tree_list (decl_specs,
build1 (INDIRECT_REF, NULL_TREE,
NULL_TREE)),
NULL_TREE));
decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)));
expr_decl = build1 (INDIRECT_REF, NULL_TREE, NULL_TREE);
push_parm_decl (build_tree_list (build_tree_list (decl_specs, expr_decl),
NULL_TREE));
parms = get_parm_info (0);
poplevel (0, 0, 0);
decl_specs = build_tree_list (NULL_TREE, objc_object_reference);
sprintf (buffer, "__objc_tmp_%x", xxx++);
expr_decl = build_nt (CALL_EXPR, get_identifier (buffer), parms, NULL_TREE);
expr_decl = build1 (INDIRECT_REF, NULL_TREE, expr_decl);
return define_decl (expr_decl, decl_specs);
}
/* Generate the prototypes for protocol methods. This is used to
generate method encodings for these.
NST_METHODS is the method to generate a _DECL node for TMP_DECL is
a decl node to be used. This is also where the return value is
given. */
static void
hack_method_prototype (nst_methods, tmp_decl)
tree nst_methods;
tree tmp_decl;
{
tree parms;
tree parm;
/* Hack to avoid problem with static typing of self arg. */
TREE_SET_CODE (nst_methods, CLASS_METHOD_DECL);
start_method_def (nst_methods);
TREE_SET_CODE (nst_methods, INSTANCE_METHOD_DECL);
if (METHOD_ADD_ARGS (nst_methods) == objc_ellipsis_node)
parms = get_parm_info (0); /* we have a `, ...' */
else
parms = get_parm_info (1); /* place a `void_at_end' */
poplevel (0, 0, 0); /* Must be called BEFORE start_function. */
/* Usually called from store_parm_decls -> init_function_start. */
DECL_ARGUMENTS (tmp_decl) = TREE_PURPOSE (parms);
if (current_function_decl)
abort ();
current_function_decl = tmp_decl;
{
/* Code taken from start_function. */
tree restype = TREE_TYPE (TREE_TYPE (tmp_decl));
/* Promote the value to int before returning it. */
if (TREE_CODE (restype) == INTEGER_TYPE
&& TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
restype = integer_type_node;
DECL_RESULT (tmp_decl) = build_decl (RESULT_DECL, 0, restype);
}
for (parm = DECL_ARGUMENTS (tmp_decl); parm; parm = TREE_CHAIN (parm))
DECL_CONTEXT (parm) = tmp_decl;
init_function_start (tmp_decl, "objc-act", 0);
/* Typically called from expand_function_start for function definitions. */
assign_parms (tmp_decl);
/* install return type */
TREE_TYPE (TREE_TYPE (tmp_decl)) = groktypename (TREE_TYPE (nst_methods));
current_function_decl = NULL;
}
static void
generate_protocol_references (plist)
tree plist;
{
tree lproto;
/* Forward declare protocols referenced. */
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
{
tree proto = TREE_VALUE (lproto);
if (TREE_CODE (proto) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_NAME (proto))
{
if (! PROTOCOL_FORWARD_DECL (proto))
build_protocol_reference (proto);
if (PROTOCOL_LIST (proto))
generate_protocol_references (PROTOCOL_LIST (proto));
}
}
}
/* For each protocol which was referenced either from a @protocol()
expression, or because a class/category implements it (then a
pointer to the protocol is stored in the struct describing the
class/category), we create a statically allocated instance of the
Protocol class. The code is written in such a way as to generate
as few Protocol objects as possible; we generate a unique Protocol
instance for each protocol, and we don't generate a Protocol
instance if the protocol is never referenced (either from a
@protocol() or from a class/category implementation). These
statically allocated objects can be referred to via the static
(that is, private to this module) symbols _OBJC_PROTOCOL_n.
The statically allocated Protocol objects that we generate here
need to be fixed up at runtime in order to be used: the 'isa'
pointer of the objects need to be set up to point to the 'Protocol'
class, as known at runtime.
The NeXT runtime fixes up all protocols at program startup time,
before main() is entered. It uses a low-level trick to look up all
those symbols, then loops on them and fixes them up.
The GNU runtime as well fixes up all protocols before user code
from the module is executed; it requires pointers to those symbols
to be put in the objc_symtab (which is then passed as argument to
the function __objc_exec_class() which the compiler sets up to be
executed automatically when the module is loaded); setup of those
Protocol objects happen in two ways in the GNU runtime: all
Protocol objects referred to by a class or category implementation
are fixed up when the class/category is loaded; all Protocol
objects referred to by a @protocol() expression are added by the
compiler to the list of statically allocated instances to fixup
(the same list holding the statically allocated constant string
objects). Because, as explained above, the compiler generates as
few Protocol objects as possible, some Protocol object might end up
being referenced multiple times when compiled with the GNU runtime,
and end up being fixed up multiple times at runtime inizialization.
But that doesn't hurt, it's just a little inefficient. */
static void
generate_protocols ()
{
tree p, tmp_decl, encoding;
tree sc_spec, decl_specs, decl;
tree initlist, protocol_name_expr, refs_decl, refs_expr;
tree cast_type2;
tmp_decl = build_tmp_function_decl ();
if (! objc_protocol_template)
objc_protocol_template = build_protocol_template ();
/* If a protocol was directly referenced, pull in indirect references. */
for (p = protocol_chain; p; p = TREE_CHAIN (p))
if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p))
generate_protocol_references (PROTOCOL_LIST (p));
for (p = protocol_chain; p; p = TREE_CHAIN (p))
{
tree nst_methods = PROTOCOL_NST_METHODS (p);
tree cls_methods = PROTOCOL_CLS_METHODS (p);
/* If protocol wasn't referenced, don't generate any code. */
if (! PROTOCOL_FORWARD_DECL (p))
continue;
/* Make sure we link in the Protocol class. */
add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
while (nst_methods)
{
if (! METHOD_ENCODING (nst_methods))
{
hack_method_prototype (nst_methods, tmp_decl);
encoding = encode_method_prototype (nst_methods, tmp_decl);
METHOD_ENCODING (nst_methods) = encoding;
}
nst_methods = TREE_CHAIN (nst_methods);
}
while (cls_methods)
{
if (! METHOD_ENCODING (cls_methods))
{
hack_method_prototype (cls_methods, tmp_decl);
encoding = encode_method_prototype (cls_methods, tmp_decl);
METHOD_ENCODING (cls_methods) = encoding;
}
cls_methods = TREE_CHAIN (cls_methods);
}
generate_method_descriptors (p);
if (PROTOCOL_LIST (p))
refs_decl = generate_protocol_list (p);
else
refs_decl = 0;
/* static struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC],
NULL_TREE);
decl_specs = tree_cons (NULL_TREE, objc_protocol_template, sc_spec);
decl = start_decl (synth_id_with_class_suffix ("_OBJC_PROTOCOL", p),
decl_specs, 1, NULL_TREE);
DECL_CONTEXT (decl) = NULL_TREE;
protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
if (refs_decl)
{
cast_type2
= groktypename
(build_tree_list (build_tree_list (NULL_TREE,
objc_protocol_template),
build1 (INDIRECT_REF, NULL_TREE,
build1 (INDIRECT_REF, NULL_TREE,
NULL_TREE))));
refs_expr = build_unary_op (ADDR_EXPR, refs_decl, 0);
TREE_TYPE (refs_expr) = cast_type2;
}
else
refs_expr = build_int_2 (0, 0);
/* UOBJC_INSTANCE_METHODS_decl/UOBJC_CLASS_METHODS_decl are set
by generate_method_descriptors, which is called above. */
initlist = build_protocol_initializer (TREE_TYPE (decl),
protocol_name_expr, refs_expr,
UOBJC_INSTANCE_METHODS_decl,
UOBJC_CLASS_METHODS_decl);
finish_decl (decl, initlist, NULL_TREE);
/* Mark the decl as used to avoid "defined but not used" warning. */
TREE_USED (decl) = 1;
}
}
static tree
build_protocol_initializer (type, protocol_name, protocol_list,
instance_methods, class_methods)
tree type;
tree protocol_name;
tree protocol_list;
tree instance_methods;
tree class_methods;
{
tree initlist = NULL_TREE, expr;
tree cast_type;
cast_type = groktypename
(build_tree_list
(build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_CLASS))),
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE)));
/* Filling the "isa" in with one allows the runtime system to
detect that the version change...should remove before final release. */
expr = build_int_2 (PROTOCOL_VERSION, 0);
TREE_TYPE (expr) = cast_type;
initlist = tree_cons (NULL_TREE, expr, initlist);
initlist = tree_cons (NULL_TREE, protocol_name, initlist);
initlist = tree_cons (NULL_TREE, protocol_list, initlist);
if (!instance_methods)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, instance_methods, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!class_methods)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, class_methods, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
return build_constructor (type, nreverse (initlist));
}
/* struct objc_category {
char *category_name;
char *class_name;
struct objc_method_list *instance_methods;
struct objc_method_list *class_methods;
struct objc_protocol_list *protocols;
}; */
static void
build_category_template ()
{
tree decl_specs, field_decl, field_decl_chain;
objc_category_template = start_struct (RECORD_TYPE,
get_identifier (UTAG_CATEGORY));
/* char *category_name; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("category_name"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
/* char *class_name; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class_name"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_method_list *instance_methods; */
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_LIST)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("instance_methods"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_method_list *class_methods; */
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_LIST)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class_methods"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_protocol **protocol_list; */
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_list"));
field_decl = build1 (INDIRECT_REF, NULL_TREE, field_decl);
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
finish_struct (objc_category_template, field_decl_chain, NULL_TREE);
}
/* struct objc_selector {
void *sel_id;
char *sel_type;
}; */
static void
build_selector_template ()
{
tree decl_specs, field_decl, field_decl_chain;
objc_selector_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_SELECTOR));
/* void *sel_id; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("sel_id"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
/* char *sel_type; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("sel_type"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
finish_struct (objc_selector_template, field_decl_chain, NULL_TREE);
}
/* struct objc_class {
struct objc_class *isa;
struct objc_class *super_class;
char *name;
long version;
long info;
long instance_size;
struct objc_ivar_list *ivars;
struct objc_method_list *methods;
if (flag_next_runtime)
struct objc_cache *cache;
else {
struct sarray *dtable;
struct objc_class *subclass_list;
struct objc_class *sibling_class;
}
struct objc_protocol_list *protocols;
void *gc_object_type;
}; */
static void
build_class_template ()
{
tree decl_specs, field_decl, field_decl_chain;
objc_class_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_CLASS));
/* struct objc_class *isa; */
decl_specs = build_tree_list (NULL_TREE, objc_class_template);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("isa"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
/* struct objc_class *super_class; */
decl_specs = build_tree_list (NULL_TREE, objc_class_template);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("super_class"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* char *name; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("name"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* long version; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
field_decl = get_identifier ("version");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* long info; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
field_decl = get_identifier ("info");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* long instance_size; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
field_decl = get_identifier ("instance_size");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_ivar_list *ivars; */
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_IVAR_LIST)));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("ivars"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_method_list *methods; */
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_LIST)));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("methods"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
if (flag_next_runtime)
{
/* struct objc_cache *cache; */
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier ("objc_cache")));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("cache"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
}
else
{
/* struct sarray *dtable; */
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier ("sarray")));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("dtable"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_class *subclass_list; */
decl_specs = build_tree_list (NULL_TREE, objc_class_template);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("subclass_list"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_class *sibling_class; */
decl_specs = build_tree_list (NULL_TREE, objc_class_template);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("sibling_class"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
}
/* struct objc_protocol **protocol_list; */
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_list"));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, field_decl);
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* void *sel_id; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("sel_id"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* void *gc_object_type; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("gc_object_type"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
finish_struct (objc_class_template, field_decl_chain, NULL_TREE);
}
/* Generate appropriate forward declarations for an implementation. */
static void
synth_forward_declarations ()
{
tree sc_spec, decl_specs, an_id;
/* extern struct objc_class _OBJC_CLASS_<my_name>; */
an_id = synth_id_with_class_suffix ("_OBJC_CLASS", objc_implementation_context);
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]);
decl_specs = tree_cons (NULL_TREE, objc_class_template, sc_spec);
UOBJC_CLASS_decl = define_decl (an_id, decl_specs);
TREE_USED (UOBJC_CLASS_decl) = 1;
DECL_ARTIFICIAL (UOBJC_CLASS_decl) = 1;
/* extern struct objc_class _OBJC_METACLASS_<my_name>; */
an_id = synth_id_with_class_suffix ("_OBJC_METACLASS",
objc_implementation_context);
UOBJC_METACLASS_decl = define_decl (an_id, decl_specs);
TREE_USED (UOBJC_METACLASS_decl) = 1;
DECL_ARTIFICIAL(UOBJC_METACLASS_decl) = 1;
/* Pre-build the following entities - for speed/convenience. */
an_id = get_identifier ("super_class");
ucls_super_ref = build_component_ref (UOBJC_CLASS_decl, an_id);
uucls_super_ref = build_component_ref (UOBJC_METACLASS_decl, an_id);
}
static void
error_with_ivar (message, decl, rawdecl)
const char *message;
tree decl;
tree rawdecl;
{
diagnostic_count_diagnostic (global_dc, DK_ERROR);
diagnostic_report_current_function (global_dc);
error_with_file_and_line (DECL_SOURCE_FILE (decl),
DECL_SOURCE_LINE (decl),
"%s `%s'",
message, gen_declaration (rawdecl, errbuf));
}
static void
check_ivars (inter, imp)
tree inter;
tree imp;
{
tree intdecls = CLASS_IVARS (inter);
tree impdecls = CLASS_IVARS (imp);
tree rawintdecls = CLASS_RAW_IVARS (inter);
tree rawimpdecls = CLASS_RAW_IVARS (imp);
while (1)
{
tree t1, t2;
if (intdecls == 0 && impdecls == 0)
break;
if (intdecls == 0 || impdecls == 0)
{
error ("inconsistent instance variable specification");
break;
}
t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls);
if (!comptypes (t1, t2))
{
if (DECL_NAME (intdecls) == DECL_NAME (impdecls))
{
error_with_ivar ("conflicting instance variable type",
impdecls, rawimpdecls);
error_with_ivar ("previous declaration of",
intdecls, rawintdecls);
}
else /* both the type and the name don't match */
{
error ("inconsistent instance variable specification");
break;
}
}
else if (DECL_NAME (intdecls) != DECL_NAME (impdecls))
{
error_with_ivar ("conflicting instance variable name",
impdecls, rawimpdecls);
error_with_ivar ("previous declaration of",
intdecls, rawintdecls);
}
intdecls = TREE_CHAIN (intdecls);
impdecls = TREE_CHAIN (impdecls);
rawintdecls = TREE_CHAIN (rawintdecls);
rawimpdecls = TREE_CHAIN (rawimpdecls);
}
}
/* Set super_type to the data type node for struct objc_super *,
first defining struct objc_super itself.
This needs to be done just once per compilation. */
static tree
build_super_template ()
{
tree record, decl_specs, field_decl, field_decl_chain;
record = start_struct (RECORD_TYPE, get_identifier (UTAG_SUPER));
/* struct objc_object *self; */
decl_specs = build_tree_list (NULL_TREE, objc_object_reference);
field_decl = get_identifier ("self");
field_decl = build1 (INDIRECT_REF, NULL_TREE, field_decl);
field_decl = grokfield (input_filename, lineno,
field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
/* struct objc_class *class; */
decl_specs = get_identifier (UTAG_CLASS);
decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE, decl_specs));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class"));
field_decl = grokfield (input_filename, lineno,
field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
finish_struct (record, field_decl_chain, NULL_TREE);
/* `struct objc_super *' */
super_type = groktypename (build_tree_list (build_tree_list (NULL_TREE,
record),
build1 (INDIRECT_REF,
NULL_TREE, NULL_TREE)));
return record;
}
/* struct objc_ivar {
char *ivar_name;
char *ivar_type;
int ivar_offset;
}; */
static tree
build_ivar_template ()
{
tree objc_ivar_id, objc_ivar_record;
tree decl_specs, field_decl, field_decl_chain;
objc_ivar_id = get_identifier (UTAG_IVAR);
objc_ivar_record = start_struct (RECORD_TYPE, objc_ivar_id);
/* char *ivar_name; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("ivar_name"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
field_decl_chain = field_decl;
/* char *ivar_type; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("ivar_type"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* int ivar_offset; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
field_decl = get_identifier ("ivar_offset");
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
finish_struct (objc_ivar_record, field_decl_chain, NULL_TREE);
return objc_ivar_record;
}
/* struct {
int ivar_count;
struct objc_ivar ivar_list[ivar_count];
}; */
static tree
build_ivar_list_template (list_type, size)
tree list_type;
int size;
{
tree objc_ivar_list_record;
tree decl_specs, field_decl, field_decl_chain;
objc_ivar_list_record = start_struct (RECORD_TYPE, NULL_TREE);
/* int ivar_count; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
field_decl = get_identifier ("ivar_count");
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
field_decl_chain = field_decl;
/* struct objc_ivar ivar_list[]; */
decl_specs = build_tree_list (NULL_TREE, list_type);
field_decl = build_nt (ARRAY_REF, get_identifier ("ivar_list"),
build_int_2 (size, 0));
field_decl = grokfield (input_filename, lineno,
field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
finish_struct (objc_ivar_list_record, field_decl_chain, NULL_TREE);
return objc_ivar_list_record;
}
/* struct {
int method_next;
int method_count;
struct objc_method method_list[method_count];
}; */
static tree
build_method_list_template (list_type, size)
tree list_type;
int size;
{
tree objc_ivar_list_record;
tree decl_specs, field_decl, field_decl_chain;
objc_ivar_list_record = start_struct (RECORD_TYPE, NULL_TREE);
/* int method_next; */
decl_specs
= build_tree_list
(NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("method_next"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
field_decl_chain = field_decl;
/* int method_count; */
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
field_decl = get_identifier ("method_count");
field_decl = grokfield (input_filename, lineno,
field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* struct objc_method method_list[]; */
decl_specs = build_tree_list (NULL_TREE, list_type);
field_decl = build_nt (ARRAY_REF, get_identifier ("method_list"),
build_int_2 (size, 0));
field_decl = grokfield (input_filename, lineno,
field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
finish_struct (objc_ivar_list_record, field_decl_chain, NULL_TREE);
return objc_ivar_list_record;
}
static tree
build_ivar_list_initializer (type, field_decl)
tree type;
tree field_decl;
{
tree initlist = NULL_TREE;
do
{
tree ivar = NULL_TREE;
/* Set name. */
if (DECL_NAME (field_decl))
ivar = tree_cons (NULL_TREE,
add_objc_string (DECL_NAME (field_decl),
meth_var_names),
ivar);
else
/* Unnamed bit-field ivar (yuck). */
ivar = tree_cons (NULL_TREE, build_int_2 (0, 0), ivar);
/* Set type. */
encode_field_decl (field_decl,
obstack_object_size (&util_obstack),
OBJC_ENCODE_DONT_INLINE_DEFS);
/* Null terminate string. */
obstack_1grow (&util_obstack, 0);
ivar
= tree_cons
(NULL_TREE,
add_objc_string (get_identifier (obstack_finish (&util_obstack)),
meth_var_types),
ivar);
obstack_free (&util_obstack, util_firstobj);
/* Set offset. */
ivar = tree_cons (NULL_TREE, byte_position (field_decl), ivar);
initlist = tree_cons (NULL_TREE,
build_constructor (type, nreverse (ivar)),
initlist);
field_decl = TREE_CHAIN (field_decl);
}
while (field_decl);
return build_constructor (build_array_type (type, 0), nreverse (initlist));
}
static tree
generate_ivars_list (type, name, size, list)
tree type;
const char *name;
int size;
tree list;
{
tree sc_spec, decl_specs, decl, initlist;
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, type, sc_spec);
decl = start_decl (synth_id_with_class_suffix (name, objc_implementation_context),
decl_specs, 1, NULL_TREE);
initlist = build_tree_list (NULL_TREE, build_int_2 (size, 0));
initlist = tree_cons (NULL_TREE, list, initlist);
finish_decl (decl,
build_constructor (TREE_TYPE (decl), nreverse (initlist)),
NULL_TREE);
return decl;
}
static void
generate_ivar_lists ()
{
tree initlist, ivar_list_template, chain;
tree cast, variable_length_type;
int size;
generating_instance_variables = 1;
if (!objc_ivar_template)
objc_ivar_template = build_ivar_template ();
cast
= build_tree_list
(build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (UTAG_IVAR_LIST))),
NULL_TREE);
variable_length_type = groktypename (cast);
/* Only generate class variables for the root of the inheritance
hierarchy since these will be the same for every class. */
if (CLASS_SUPER_NAME (implementation_template) == NULL_TREE
&& (chain = TYPE_FIELDS (objc_class_template)))
{
size = list_length (chain);
ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
initlist = build_ivar_list_initializer (objc_ivar_template, chain);
UOBJC_CLASS_VARIABLES_decl
= generate_ivars_list (ivar_list_template, "_OBJC_CLASS_VARIABLES",
size, initlist);
TREE_TYPE (UOBJC_CLASS_VARIABLES_decl) = variable_length_type;
}
else
UOBJC_CLASS_VARIABLES_decl = 0;
chain = CLASS_IVARS (implementation_template);
if (chain)
{
size = list_length (chain);
ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
initlist = build_ivar_list_initializer (objc_ivar_template, chain);
UOBJC_INSTANCE_VARIABLES_decl
= generate_ivars_list (ivar_list_template, "_OBJC_INSTANCE_VARIABLES",
size, initlist);
TREE_TYPE (UOBJC_INSTANCE_VARIABLES_decl) = variable_length_type;
}
else
UOBJC_INSTANCE_VARIABLES_decl = 0;
generating_instance_variables = 0;
}
static tree
build_dispatch_table_initializer (type, entries)
tree type;
tree entries;
{
tree initlist = NULL_TREE;
do
{
tree elemlist = NULL_TREE;
elemlist = tree_cons (NULL_TREE,
build_selector (METHOD_SEL_NAME (entries)),
NULL_TREE);
/* Generate the method encoding if we don't have one already. */
if (! METHOD_ENCODING (entries))
METHOD_ENCODING (entries) =
encode_method_def (METHOD_DEFINITION (entries));
elemlist = tree_cons (NULL_TREE,
add_objc_string (METHOD_ENCODING (entries),
meth_var_types),
elemlist);
elemlist = tree_cons (NULL_TREE,
build_unary_op (ADDR_EXPR,
METHOD_DEFINITION (entries), 1),
elemlist);
initlist = tree_cons (NULL_TREE,
build_constructor (type, nreverse (elemlist)),
initlist);
entries = TREE_CHAIN (entries);
}
while (entries);
return build_constructor (build_array_type (type, 0), nreverse (initlist));
}
/* To accomplish method prototyping without generating all kinds of
inane warnings, the definition of the dispatch table entries were
changed from:
struct objc_method { SEL _cmd; ...; id (*_imp)(); };
to:
struct objc_method { SEL _cmd; ...; void *_imp; }; */
static tree
build_method_template ()
{
tree _SLT_record;
tree decl_specs, field_decl, field_decl_chain;
_SLT_record = start_struct (RECORD_TYPE, get_identifier (UTAG_METHOD));
/* struct objc_selector *_cmd; */
decl_specs = tree_cons (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)),
NULL_TREE);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("_cmd"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], NULL_TREE);
field_decl = build1 (INDIRECT_REF, NULL_TREE,
get_identifier ("method_types"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
/* void *_imp; */
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_VOID], NULL_TREE);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("_imp"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
finish_struct (_SLT_record, field_decl_chain, NULL_TREE);
return _SLT_record;
}
static tree
generate_dispatch_table (type, name, size, list)
tree type;
const char *name;
int size;
tree list;
{
tree sc_spec, decl_specs, decl, initlist;
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, type, sc_spec);
decl = start_decl (synth_id_with_class_suffix (name, objc_implementation_context),
decl_specs, 1, NULL_TREE);
initlist = build_tree_list (NULL_TREE, build_int_2 (0, 0));
initlist = tree_cons (NULL_TREE, build_int_2 (size, 0), initlist);
initlist = tree_cons (NULL_TREE, list, initlist);
finish_decl (decl,
build_constructor (TREE_TYPE (decl), nreverse (initlist)),
NULL_TREE);
return decl;
}
static void
generate_dispatch_tables ()
{
tree initlist, chain, method_list_template;
tree cast, variable_length_type;
int size;
if (!objc_method_template)
objc_method_template = build_method_template ();
cast
= build_tree_list
(build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_LIST))),
NULL_TREE);
variable_length_type = groktypename (cast);
chain = CLASS_CLS_METHODS (objc_implementation_context);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_list_template (objc_method_template, size);
initlist
= build_dispatch_table_initializer (objc_method_template, chain);
UOBJC_CLASS_METHODS_decl
= generate_dispatch_table (method_list_template,
((TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
? "_OBJC_CLASS_METHODS"
: "_OBJC_CATEGORY_CLASS_METHODS"),
size, initlist);
TREE_TYPE (UOBJC_CLASS_METHODS_decl) = variable_length_type;
}
else
UOBJC_CLASS_METHODS_decl = 0;
chain = CLASS_NST_METHODS (objc_implementation_context);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_list_template (objc_method_template, size);
initlist
= build_dispatch_table_initializer (objc_method_template, chain);
if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
UOBJC_INSTANCE_METHODS_decl
= generate_dispatch_table (method_list_template,
"_OBJC_INSTANCE_METHODS",
size, initlist);
else
/* We have a category. */
UOBJC_INSTANCE_METHODS_decl
= generate_dispatch_table (method_list_template,
"_OBJC_CATEGORY_INSTANCE_METHODS",
size, initlist);
TREE_TYPE (UOBJC_INSTANCE_METHODS_decl) = variable_length_type;
}
else
UOBJC_INSTANCE_METHODS_decl = 0;
}
static tree
generate_protocol_list (i_or_p)
tree i_or_p;
{
tree initlist, decl_specs, sc_spec;
tree refs_decl, expr_decl, lproto, e, plist;
tree cast_type;
int size = 0;
if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE
|| TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
plist = CLASS_PROTOCOL_LIST (i_or_p);
else if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
plist = PROTOCOL_LIST (i_or_p);
else
abort ();
cast_type = groktypename
(build_tree_list
(build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL))),
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE)));
/* Compute size. */
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto)))
size++;
/* Build initializer. */
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), NULL_TREE);
e = build_int_2 (size, 0);
TREE_TYPE (e) = cast_type;
initlist = tree_cons (NULL_TREE, e, initlist);
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
{
tree pval = TREE_VALUE (lproto);
if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_FORWARD_DECL (pval))
{
e = build_unary_op (ADDR_EXPR, PROTOCOL_FORWARD_DECL (pval), 0);
initlist = tree_cons (NULL_TREE, e, initlist);
}
}
/* static struct objc_protocol *refs[n]; */
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL)),
sc_spec);
if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
expr_decl = build_nt (ARRAY_REF,
synth_id_with_class_suffix ("_OBJC_PROTOCOL_REFS",
i_or_p),
build_int_2 (size + 2, 0));
else if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE)
expr_decl = build_nt (ARRAY_REF,
synth_id_with_class_suffix ("_OBJC_CLASS_PROTOCOLS",
i_or_p),
build_int_2 (size + 2, 0));
else if (TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
expr_decl
= build_nt (ARRAY_REF,
synth_id_with_class_suffix ("_OBJC_CATEGORY_PROTOCOLS",
i_or_p),
build_int_2 (size + 2, 0));
else
abort ();
expr_decl = build1 (INDIRECT_REF, NULL_TREE, expr_decl);
refs_decl = start_decl (expr_decl, decl_specs, 1, NULL_TREE);
DECL_CONTEXT (refs_decl) = NULL_TREE;
finish_decl (refs_decl, build_constructor (TREE_TYPE (refs_decl),
nreverse (initlist)),
NULL_TREE);
return refs_decl;
}
static tree
build_category_initializer (type, cat_name, class_name,
instance_methods, class_methods, protocol_list)
tree type;
tree cat_name;
tree class_name;
tree instance_methods;
tree class_methods;
tree protocol_list;
{
tree initlist = NULL_TREE, expr;
initlist = tree_cons (NULL_TREE, cat_name, initlist);
initlist = tree_cons (NULL_TREE, class_name, initlist);
if (!instance_methods)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, instance_methods, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!class_methods)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, class_methods, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
/* protocol_list = */
if (!protocol_list)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
tree cast_type2 = groktypename
(build_tree_list
(build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL))),
build1 (INDIRECT_REF, NULL_TREE,
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE))));
expr = build_unary_op (ADDR_EXPR, protocol_list, 0);
TREE_TYPE (expr) = cast_type2;
initlist = tree_cons (NULL_TREE, expr, initlist);
}
return build_constructor (type, nreverse (initlist));
}
/* struct objc_class {
struct objc_class *isa;
struct objc_class *super_class;
char *name;
long version;
long info;
long instance_size;
struct objc_ivar_list *ivars;
struct objc_method_list *methods;
if (flag_next_runtime)
struct objc_cache *cache;
else {
struct sarray *dtable;
struct objc_class *subclass_list;
struct objc_class *sibling_class;
}
struct objc_protocol_list *protocols;
void *gc_object_type;
}; */
static tree
build_shared_structure_initializer (type, isa, super, name, size, status,
dispatch_table, ivar_list, protocol_list)
tree type;
tree isa;
tree super;
tree name;
tree size;
int status;
tree dispatch_table;
tree ivar_list;
tree protocol_list;
{
tree initlist = NULL_TREE, expr;
/* isa = */
initlist = tree_cons (NULL_TREE, isa, initlist);
/* super_class = */
initlist = tree_cons (NULL_TREE, super, initlist);
/* name = */
initlist = tree_cons (NULL_TREE, default_conversion (name), initlist);
/* version = */
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
/* info = */
initlist = tree_cons (NULL_TREE, build_int_2 (status, 0), initlist);
/* instance_size = */
initlist = tree_cons (NULL_TREE, size, initlist);
/* objc_ivar_list = */
if (!ivar_list)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, ivar_list, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
/* objc_method_list = */
if (!dispatch_table)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, dispatch_table, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (flag_next_runtime)
/* method_cache = */
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
/* dtable = */
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
/* subclass_list = */
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
/* sibling_class = */
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
}
/* protocol_list = */
if (! protocol_list)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
tree cast_type2
= groktypename
(build_tree_list
(build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL))),
build1 (INDIRECT_REF, NULL_TREE,
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE))));
expr = build_unary_op (ADDR_EXPR, protocol_list, 0);
TREE_TYPE (expr) = cast_type2;
initlist = tree_cons (NULL_TREE, expr, initlist);
}
/* gc_object_type = NULL */
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
return build_constructor (type, nreverse (initlist));
}
/* static struct objc_category _OBJC_CATEGORY_<name> = { ... }; */
static void
generate_category (cat)
tree cat;
{
tree sc_spec, decl_specs, decl;
tree initlist, cat_name_expr, class_name_expr;
tree protocol_decl, category;
add_class_reference (CLASS_NAME (cat));
cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names);
class_name_expr = add_objc_string (CLASS_NAME (cat), class_names);
category = CLASS_CATEGORY_LIST (implementation_template);
/* find the category interface from the class it is associated with */
while (category)
{
if (CLASS_SUPER_NAME (cat) == CLASS_SUPER_NAME (category))
break;
category = CLASS_CATEGORY_LIST (category);
}
if (category && CLASS_PROTOCOL_LIST (category))
{
generate_protocol_references (CLASS_PROTOCOL_LIST (category));
protocol_decl = generate_protocol_list (category);
}
else
protocol_decl = 0;
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, objc_category_template, sc_spec);
decl = start_decl (synth_id_with_class_suffix ("_OBJC_CATEGORY",
objc_implementation_context),
decl_specs, 1, NULL_TREE);
initlist = build_category_initializer (TREE_TYPE (decl),
cat_name_expr, class_name_expr,
UOBJC_INSTANCE_METHODS_decl,
UOBJC_CLASS_METHODS_decl,
protocol_decl);
TREE_USED (decl) = 1;
finish_decl (decl, initlist, NULL_TREE);
}
/* static struct objc_class _OBJC_METACLASS_Foo={ ... };
static struct objc_class _OBJC_CLASS_Foo={ ... }; */
static void
generate_shared_structures ()
{
tree sc_spec, decl_specs, decl;
tree name_expr, super_expr, root_expr;
tree my_root_id = NULL_TREE, my_super_id = NULL_TREE;
tree cast_type, initlist, protocol_decl;
my_super_id = CLASS_SUPER_NAME (implementation_template);
if (my_super_id)
{
add_class_reference (my_super_id);
/* Compute "my_root_id" - this is required for code generation.
the "isa" for all meta class structures points to the root of
the inheritance hierarchy (e.g. "__Object")... */
my_root_id = my_super_id;
do
{
tree my_root_int = lookup_interface (my_root_id);
if (my_root_int && CLASS_SUPER_NAME (my_root_int))
my_root_id = CLASS_SUPER_NAME (my_root_int);
else
break;
}
while (1);
}
else
/* No super class. */
my_root_id = CLASS_NAME (implementation_template);
cast_type
= groktypename (build_tree_list (build_tree_list (NULL_TREE,
objc_class_template),
build1 (INDIRECT_REF,
NULL_TREE, NULL_TREE)));
name_expr = add_objc_string (CLASS_NAME (implementation_template),
class_names);
/* Install class `isa' and `super' pointers at runtime. */
if (my_super_id)
{
super_expr = add_objc_string (my_super_id, class_names);
super_expr = build_c_cast (cast_type, super_expr); /* cast! */
}
else
super_expr = build_int_2 (0, 0);
root_expr = add_objc_string (my_root_id, class_names);
root_expr = build_c_cast (cast_type, root_expr); /* cast! */
if (CLASS_PROTOCOL_LIST (implementation_template))
{
generate_protocol_references
(CLASS_PROTOCOL_LIST (implementation_template));
protocol_decl = generate_protocol_list (implementation_template);
}
else
protocol_decl = 0;
/* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
decl_specs = tree_cons (NULL_TREE, objc_class_template, sc_spec);
decl = start_decl (DECL_NAME (UOBJC_METACLASS_decl), decl_specs, 1,
NULL_TREE);
initlist
= build_shared_structure_initializer
(TREE_TYPE (decl),
root_expr, super_expr, name_expr,
convert (integer_type_node, TYPE_SIZE_UNIT (objc_class_template)),
2 /*CLS_META*/,
UOBJC_CLASS_METHODS_decl,
UOBJC_CLASS_VARIABLES_decl,
protocol_decl);
finish_decl (decl, initlist, NULL_TREE);
/* static struct objc_class _OBJC_CLASS_Foo={ ... }; */
decl = start_decl (DECL_NAME (UOBJC_CLASS_decl), decl_specs, 1,
NULL_TREE);
initlist
= build_shared_structure_initializer
(TREE_TYPE (decl),
build_unary_op (ADDR_EXPR, UOBJC_METACLASS_decl, 0),
super_expr, name_expr,
convert (integer_type_node,
TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE
(implementation_template))),
1 /*CLS_FACTORY*/,
UOBJC_INSTANCE_METHODS_decl,
UOBJC_INSTANCE_VARIABLES_decl,
protocol_decl);
finish_decl (decl, initlist, NULL_TREE);
}
static tree
synth_id_with_class_suffix (preamble, ctxt)
const char *preamble;
tree ctxt;
{
char *string;
if (TREE_CODE (ctxt) == CLASS_IMPLEMENTATION_TYPE
|| TREE_CODE (ctxt) == CLASS_INTERFACE_TYPE)
{
const char *const class_name
= IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
string = (char *) alloca (strlen (preamble) + strlen (class_name) + 3);
sprintf (string, "%s_%s", preamble,
IDENTIFIER_POINTER (CLASS_NAME (ctxt)));
}
else if (TREE_CODE (ctxt) == CATEGORY_IMPLEMENTATION_TYPE
|| TREE_CODE (ctxt) == CATEGORY_INTERFACE_TYPE)
{
/* We have a category. */
const char *const class_name
= IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
const char *const class_super_name
= IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context));
string = (char *) alloca (strlen (preamble)
+ strlen (class_name)
+ strlen (class_super_name)
+ 3);
sprintf (string, "%s_%s_%s", preamble, class_name, class_super_name);
}
else if (TREE_CODE (ctxt) == PROTOCOL_INTERFACE_TYPE)
{
const char *protocol_name = IDENTIFIER_POINTER (PROTOCOL_NAME (ctxt));
string
= (char *) alloca (strlen (preamble) + strlen (protocol_name) + 3);
sprintf (string, "%s_%s", preamble, protocol_name);
}
else
abort ();
return get_identifier (string);
}
static int
is_objc_type_qualifier (node)
tree node;
{
return (TREE_CODE (node) == IDENTIFIER_NODE
&& (node == ridpointers [(int) RID_CONST]
|| node == ridpointers [(int) RID_VOLATILE]
|| node == ridpointers [(int) RID_IN]
|| node == ridpointers [(int) RID_OUT]
|| node == ridpointers [(int) RID_INOUT]
|| node == ridpointers [(int) RID_BYCOPY]
|| node == ridpointers [(int) RID_BYREF]
|| node == ridpointers [(int) RID_ONEWAY]));
}
/* If type is empty or only type qualifiers are present, add default
type of id (otherwise grokdeclarator will default to int). */
static tree
adjust_type_for_id_default (type)
tree type;
{
tree declspecs, chain;
if (!type)
return build_tree_list (build_tree_list (NULL_TREE, objc_object_reference),
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE));
declspecs = TREE_PURPOSE (type);
/* Determine if a typespec is present. */
for (chain = declspecs;
chain;
chain = TREE_CHAIN (chain))
{
if (TYPED_OBJECT (TREE_VALUE (chain))
&& !(TREE_VALUE (type)
&& TREE_CODE (TREE_VALUE (type)) == INDIRECT_REF))
error ("can not use an object as parameter to a method\n");
if (!is_objc_type_qualifier (TREE_VALUE (chain)))
return type;
}
return build_tree_list (tree_cons (NULL_TREE, objc_object_reference,
declspecs),
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE));
}
/* Usage:
keyworddecl:
selector ':' '(' typename ')' identifier
Purpose:
Transform an Objective-C keyword argument into
the C equivalent parameter declarator.
In: key_name, an "identifier_node" (optional).
arg_type, a "tree_list" (optional).
arg_name, an "identifier_node".
Note: It would be really nice to strongly type the preceding
arguments in the function prototype; however, then I
could not use the "accessor" macros defined in "tree.h".
Out: an instance of "keyword_decl". */
tree
build_keyword_decl (key_name, arg_type, arg_name)
tree key_name;
tree arg_type;
tree arg_name;
{
tree keyword_decl;
/* If no type is specified, default to "id". */
arg_type = adjust_type_for_id_default (arg_type);
keyword_decl = make_node (KEYWORD_DECL);
TREE_TYPE (keyword_decl) = arg_type;
KEYWORD_ARG_NAME (keyword_decl) = arg_name;
KEYWORD_KEY_NAME (keyword_decl) = key_name;
return keyword_decl;
}
/* Given a chain of keyword_decl's, synthesize the full keyword selector. */
static tree
build_keyword_selector (selector)
tree selector;
{
int len = 0;
tree key_chain, key_name;
char *buf;
/* Scan the selector to see how much space we'll need. */
for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
{
if (TREE_CODE (selector) == KEYWORD_DECL)
key_name = KEYWORD_KEY_NAME (key_chain);
else if (TREE_CODE (selector) == TREE_LIST)
key_name = TREE_PURPOSE (key_chain);
else
abort ();
if (key_name)
len += IDENTIFIER_LENGTH (key_name) + 1;
else
/* Just a ':' arg. */
len++;
}
buf = (char *) alloca (len + 1);
/* Start the buffer out as an empty string. */
buf[0] = '\0';
for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
{
if (TREE_CODE (selector) == KEYWORD_DECL)
key_name = KEYWORD_KEY_NAME (key_chain);
else if (TREE_CODE (selector) == TREE_LIST)
key_name = TREE_PURPOSE (key_chain);
else
abort ();
if (key_name)
strcat (buf, IDENTIFIER_POINTER (key_name));
strcat (buf, ":");
}
return get_identifier (buf);
}
/* Used for declarations and definitions. */
tree
build_method_decl (code, ret_type, selector, add_args)
enum tree_code code;
tree ret_type;
tree selector;
tree add_args;
{
tree method_decl;
/* If no type is specified, default to "id". */
ret_type = adjust_type_for_id_default (ret_type);
method_decl = make_node (code);
TREE_TYPE (method_decl) = ret_type;
/* If we have a keyword selector, create an identifier_node that
represents the full selector name (`:' included)... */
if (TREE_CODE (selector) == KEYWORD_DECL)
{
METHOD_SEL_NAME (method_decl) = build_keyword_selector (selector);
METHOD_SEL_ARGS (method_decl) = selector;
METHOD_ADD_ARGS (method_decl) = add_args;
}
else
{
METHOD_SEL_NAME (method_decl) = selector;
METHOD_SEL_ARGS (method_decl) = NULL_TREE;
METHOD_ADD_ARGS (method_decl) = NULL_TREE;
}
return method_decl;
}
#define METHOD_DEF 0
#define METHOD_REF 1
/* Used by `build_objc_method_call' and `comp_method_types'. Return
an argument list for method METH. CONTEXT is either METHOD_DEF or
METHOD_REF, saying whether we are trying to define a method or call
one. SUPERFLAG says this is for a send to super; this makes a
difference for the NeXT calling sequence in which the lookup and
the method call are done together. */
static tree
get_arg_type_list (meth, context, superflag)
tree meth;
int context;
int superflag;
{
tree arglist, akey;
/* Receiver type. */
if (flag_next_runtime && superflag)
arglist = build_tree_list (NULL_TREE, super_type);
else if (context == METHOD_DEF)
arglist = build_tree_list (NULL_TREE, TREE_TYPE (self_decl));
else
arglist = build_tree_list (NULL_TREE, id_type);
/* Selector type - will eventually change to `int'. */
chainon (arglist, build_tree_list (NULL_TREE, selector_type));
/* Build a list of argument types. */
for (akey = METHOD_SEL_ARGS (meth); akey; akey = TREE_CHAIN (akey))
{
tree arg_decl = groktypename_in_parm_context (TREE_TYPE (akey));
chainon (arglist, build_tree_list (NULL_TREE, TREE_TYPE (arg_decl)));
}
if (METHOD_ADD_ARGS (meth) == objc_ellipsis_node)
/* We have a `, ...' immediately following the selector,
finalize the arglist...simulate get_parm_info (0). */
;
else if (METHOD_ADD_ARGS (meth))
{
/* we have a variable length selector */
tree add_arg_list = TREE_CHAIN (METHOD_ADD_ARGS (meth));
chainon (arglist, add_arg_list);
}
else
/* finalize the arglist...simulate get_parm_info (1) */
chainon (arglist, build_tree_list (NULL_TREE, void_type_node));
return arglist;
}
static tree
check_duplicates (hsh)
hash hsh;
{
tree meth = NULL_TREE;
if (hsh)
{
meth = hsh->key;
if (hsh->list)
{
/* We have two methods with the same name and different types. */
attr loop;
char type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL) ? '-' : '+';
warning ("multiple declarations for method `%s'",
IDENTIFIER_POINTER (METHOD_SEL_NAME (meth)));
warn_with_method ("using", type, meth);
for (loop = hsh->list; loop; loop = loop->next)
warn_with_method ("also found", type, loop->value);
}
}
return meth;
}
/* If RECEIVER is a class reference, return the identifier node for
the referenced class. RECEIVER is created by get_class_reference,
so we check the exact form created depending on which runtimes are
used. */
static tree
receiver_is_class_object (receiver)
tree receiver;
{
tree chain, exp, arg;
/* The receiver is 'self' in the context of a class method. */
if (objc_method_context
&& receiver == self_decl
&& TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
{
return CLASS_NAME (objc_implementation_context);
}
if (flag_next_runtime)
{
/* The receiver is a variable created by
build_class_reference_decl. */
if (TREE_CODE (receiver) == VAR_DECL
&& TREE_TYPE (receiver) == objc_class_type)
/* Look up the identifier. */
for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
if (TREE_PURPOSE (chain) == receiver)
return TREE_VALUE (chain);
}
else
{
/* The receiver is a function call that returns an id. Check if
it is a call to objc_getClass, if so, pick up the class name. */
if (TREE_CODE (receiver) == CALL_EXPR
&& (exp = TREE_OPERAND (receiver, 0))
&& TREE_CODE (exp) == ADDR_EXPR
&& (exp = TREE_OPERAND (exp, 0))
&& TREE_CODE (exp) == FUNCTION_DECL
&& exp == objc_get_class_decl
/* We have a call to objc_getClass! */
&& (arg = TREE_OPERAND (receiver, 1))
&& TREE_CODE (arg) == TREE_LIST
&& (arg = TREE_VALUE (arg)))
{
STRIP_NOPS (arg);
if (TREE_CODE (arg) == ADDR_EXPR
&& (arg = TREE_OPERAND (arg, 0))
&& TREE_CODE (arg) == STRING_CST)
/* Finally, we have the class name. */
return get_identifier (TREE_STRING_POINTER (arg));
}
}
return 0;
}
/* If we are currently building a message expr, this holds
the identifier of the selector of the message. This is
used when printing warnings about argument mismatches. */
static tree current_objc_message_selector = 0;
tree
objc_message_selector ()
{
return current_objc_message_selector;
}
/* Construct an expression for sending a message.
MESS has the object to send to in TREE_PURPOSE
and the argument list (including selector) in TREE_VALUE.
(*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...);
(*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...); */
tree
build_message_expr (mess)
tree mess;
{
tree receiver = TREE_PURPOSE (mess);
tree sel_name;
tree args = TREE_VALUE (mess);
tree method_params = NULL_TREE;
if (TREE_CODE (receiver) == ERROR_MARK)
return error_mark_node;
/* Obtain the full selector name. */
if (TREE_CODE (args) == IDENTIFIER_NODE)
/* A unary selector. */
sel_name = args;
else if (TREE_CODE (args) == TREE_LIST)
sel_name = build_keyword_selector (args);
else
abort ();
/* Build the parameter list to give to the method. */
if (TREE_CODE (args) == TREE_LIST)
{
tree chain = args, prev = NULL_TREE;
/* We have a keyword selector--check for comma expressions. */
while (chain)
{
tree element = TREE_VALUE (chain);
/* We have a comma expression, must collapse... */
if (TREE_CODE (element) == TREE_LIST)
{
if (prev)
TREE_CHAIN (prev) = element;
else
args = element;
}
prev = chain;
chain = TREE_CHAIN (chain);
}
method_params = args;
}
return finish_message_expr (receiver, sel_name, method_params);
}
/* The 'finish_message_expr' routine is called from within
'build_message_expr' for non-template functions. In the case of
C++ template functions, it is called from 'build_expr_from_tree'
(in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded. */
tree
finish_message_expr (receiver, sel_name, method_params)
tree receiver, sel_name, method_params;
{
tree method_prototype = NULL_TREE, class_ident = NULL_TREE;
tree selector, self_object, retval;
int statically_typed = 0, statically_allocated = 0;
/* Determine receiver type. */
tree rtype = TREE_TYPE (receiver);
int super = IS_SUPER (rtype);
if (! super)
{
if (TREE_STATIC_TEMPLATE (rtype))
statically_allocated = 1;
else if (TREE_CODE (rtype) == POINTER_TYPE
&& TREE_STATIC_TEMPLATE (TREE_TYPE (rtype)))
statically_typed = 1;
else if ((flag_next_runtime
|| (IS_ID (rtype)))
&& (class_ident = receiver_is_class_object (receiver)))
;
else if (! IS_ID (rtype)
/* Allow any type that matches objc_class_type. */
&& ! comptypes (rtype, objc_class_type))
{
warning ("invalid receiver type `%s'",
gen_declaration (rtype, errbuf));
}
if (statically_allocated)
receiver = build_unary_op (ADDR_EXPR, receiver, 0);
/* Don't evaluate the receiver twice. */
receiver = save_expr (receiver);
self_object = receiver;
}
else
/* If sending to `super', use current self as the object. */
self_object = self_decl;
/* Determine operation return type. */
if (super)
{
tree iface;
if (CLASS_SUPER_NAME (implementation_template))
{
iface
= lookup_interface (CLASS_SUPER_NAME (implementation_template));
if (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL)
method_prototype = lookup_instance_method_static (iface, sel_name);
else
method_prototype = lookup_class_method_static (iface, sel_name);
if (iface && !method_prototype)
warning ("`%s' does not respond to `%s'",
IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_template)),
IDENTIFIER_POINTER (sel_name));
}
else
{
error ("no super class declared in interface for `%s'",
IDENTIFIER_POINTER (CLASS_NAME (implementation_template)));
return error_mark_node;
}
}
else if (statically_allocated)
{
tree ctype = TREE_TYPE (rtype);
tree iface = lookup_interface (TYPE_NAME (rtype));
if (iface)
method_prototype = lookup_instance_method_static (iface, sel_name);
if (! method_prototype && ctype && TYPE_PROTOCOL_LIST (ctype))
method_prototype
= lookup_method_in_protocol_list (TYPE_PROTOCOL_LIST (ctype),
sel_name, 0);
if (!method_prototype)
warning ("`%s' does not respond to `%s'",
IDENTIFIER_POINTER (TYPE_NAME (rtype)),
IDENTIFIER_POINTER (sel_name));
}
else if (statically_typed)
{
tree ctype = TREE_TYPE (rtype);
/* `self' is now statically_typed. All methods should be visible
within the context of the implementation. */
if (objc_implementation_context
&& CLASS_NAME (objc_implementation_context) == TYPE_NAME (ctype))
{
method_prototype
= lookup_instance_method_static (implementation_template,
sel_name);
if (! method_prototype && TYPE_PROTOCOL_LIST (ctype))
method_prototype
= lookup_method_in_protocol_list (TYPE_PROTOCOL_LIST (ctype),
sel_name, 0);
if (! method_prototype
&& implementation_template != objc_implementation_context)
/* The method is not published in the interface. Check
locally. */
method_prototype
= lookup_method (CLASS_NST_METHODS (objc_implementation_context),
sel_name);
}
else
{
tree iface;
if ((iface = lookup_interface (TYPE_NAME (ctype))))
method_prototype = lookup_instance_method_static (iface, sel_name);
if (! method_prototype)
{
tree protocol_list = TYPE_PROTOCOL_LIST (ctype);
if (protocol_list)
method_prototype
= lookup_method_in_protocol_list (protocol_list,
sel_name, 0);
}
}
if (!method_prototype)
warning ("`%s' does not respond to `%s'",
IDENTIFIER_POINTER (TYPE_NAME (ctype)),
IDENTIFIER_POINTER (sel_name));
}
else if (class_ident)
{
if (objc_implementation_context
&& CLASS_NAME (objc_implementation_context) == class_ident)
{
method_prototype
= lookup_class_method_static (implementation_template, sel_name);
if (!method_prototype
&& implementation_template != objc_implementation_context)
/* The method is not published in the interface. Check
locally. */
method_prototype
= lookup_method (CLASS_CLS_METHODS (objc_implementation_context),
sel_name);
}
else
{
tree iface;
if ((iface = lookup_interface (class_ident)))
method_prototype = lookup_class_method_static (iface, sel_name);
}
if (!method_prototype)
{
warning ("cannot find class (factory) method");
warning ("return type for `%s' defaults to id",
IDENTIFIER_POINTER (sel_name));
}
}
else if (IS_PROTOCOL_QUALIFIED_ID (rtype))
{
/* An anonymous object that has been qualified with a protocol. */
tree protocol_list = TYPE_PROTOCOL_LIST (rtype);
method_prototype = lookup_method_in_protocol_list (protocol_list,
sel_name, 0);
if (!method_prototype)
{
hash hsh;
warning ("method `%s' not implemented by protocol",
IDENTIFIER_POINTER (sel_name));
/* Try and find the method signature in the global pools. */
if (!(hsh = hash_lookup (nst_method_hash_list, sel_name)))
hsh = hash_lookup (cls_method_hash_list, sel_name);
if (!(method_prototype = check_duplicates (hsh)))
warning ("return type defaults to id");
}
}
else
{
hash hsh;
/* We think we have an instance...loophole: extern id Object; */
hsh = hash_lookup (nst_method_hash_list, sel_name);
if (!hsh)
/* For various loopholes */
hsh = hash_lookup (cls_method_hash_list, sel_name);
method_prototype = check_duplicates (hsh);
if (!method_prototype)
{
warning ("cannot find method");
warning ("return type for `%s' defaults to id",
IDENTIFIER_POINTER (sel_name));
}
}
/* Save the selector name for printing error messages. */
current_objc_message_selector = sel_name;
/* Build the parameters list for looking up the method.
These are the object itself and the selector. */
if (flag_typed_selectors)
selector = build_typed_selector_reference (sel_name, method_prototype);
else
selector = build_selector_reference (sel_name);
retval = build_objc_method_call (super, method_prototype,
receiver, self_object,
selector, method_params);
current_objc_message_selector = 0;
return retval;
}
/* Build a tree expression to send OBJECT the operation SELECTOR,
looking up the method on object LOOKUP_OBJECT (often same as OBJECT),
assuming the method has prototype METHOD_PROTOTYPE.
(That is an INSTANCE_METHOD_DECL or CLASS_METHOD_DECL.)
Use METHOD_PARAMS as list of args to pass to the method.
If SUPER_FLAG is nonzero, we look up the superclass's method. */
static tree
build_objc_method_call (super_flag, method_prototype, lookup_object, object,
selector, method_params)
int super_flag;
tree method_prototype, lookup_object, object, selector, method_params;
{
tree sender = (super_flag ? umsg_super_decl : umsg_decl);
tree rcv_p = (super_flag
? build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (TAG_SUPER)))
: id_type);
if (flag_next_runtime)
{
if (! method_prototype)
{
method_params = tree_cons (NULL_TREE, lookup_object,
tree_cons (NULL_TREE, selector,
method_params));
assemble_external (sender);
return build_function_call (sender, method_params);
}
else
{
/* This is a real kludge, but it is used only for the Next.
Clobber the data type of SENDER temporarily to accept
all the arguments for this operation, and to return
whatever this operation returns. */
tree arglist = NULL_TREE, retval, savarg, savret;
tree ret_type = groktypename (TREE_TYPE (method_prototype));
/* Save the proper contents of SENDER's data type. */
savarg = TYPE_ARG_TYPES (TREE_TYPE (sender));
savret = TREE_TYPE (TREE_TYPE (sender));
/* Install this method's argument types. */
arglist = get_arg_type_list (method_prototype, METHOD_REF,
super_flag);
TYPE_ARG_TYPES (TREE_TYPE (sender)) = arglist;
/* Install this method's return type. */
TREE_TYPE (TREE_TYPE (sender)) = ret_type;
/* Call SENDER with all the parameters. This will do type
checking using the arg types for this method. */
method_params = tree_cons (NULL_TREE, lookup_object,
tree_cons (NULL_TREE, selector,
method_params));
assemble_external (sender);
retval = build_function_call (sender, method_params);
/* Restore SENDER's return/argument types. */
TYPE_ARG_TYPES (TREE_TYPE (sender)) = savarg;
TREE_TYPE (TREE_TYPE (sender)) = savret;
return retval;
}
}
else
{
/* This is the portable way.
First call the lookup function to get a pointer to the method,
then cast the pointer, then call it with the method arguments. */
tree method;
/* Avoid trouble since we may evaluate each of these twice. */
object = save_expr (object);
selector = save_expr (selector);
lookup_object = build_c_cast (rcv_p, lookup_object);
assemble_external (sender);
method
= build_function_call (sender,
tree_cons (NULL_TREE, lookup_object,
tree_cons (NULL_TREE, selector,
NULL_TREE)));
/* If we have a method prototype, construct the data type this
method needs, and cast what we got from SENDER into a pointer
to that type. */
if (method_prototype)
{
tree arglist = get_arg_type_list (method_prototype, METHOD_REF,
super_flag);
tree valtype = groktypename (TREE_TYPE (method_prototype));
tree fake_function_type = build_function_type (valtype, arglist);
TREE_TYPE (method) = build_pointer_type (fake_function_type);
}
else
TREE_TYPE (method)
= build_pointer_type (build_function_type (ptr_type_node, NULL_TREE));
/* Pass the object to the method. */
assemble_external (method);
return build_function_call (method,
tree_cons (NULL_TREE, object,
tree_cons (NULL_TREE, selector,
method_params)));
}
}
static void
build_protocol_reference (p)
tree p;
{
tree decl, ident, ptype;
/* extern struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
ident = synth_id_with_class_suffix ("_OBJC_PROTOCOL", p);
ptype
= groktypename (build_tree_list (build_tree_list (NULL_TREE,
objc_protocol_template),
NULL_TREE));
if (IDENTIFIER_GLOBAL_VALUE (ident))
decl = IDENTIFIER_GLOBAL_VALUE (ident); /* Set by pushdecl. */
else
{
decl = build_decl (VAR_DECL, ident, ptype);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
TREE_USED (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
make_decl_rtl (decl, 0);
pushdecl_top_level (decl);
}
PROTOCOL_FORWARD_DECL (p) = decl;
}
/* This function is called by the parser when (and only when) a
@protocol() expression is found, in order to compile it. */
tree
build_protocol_expr (protoname)
tree protoname;
{
tree expr;
tree p = lookup_protocol (protoname);
if (!p)
{
error ("cannot find protocol declaration for `%s'",
IDENTIFIER_POINTER (protoname));
return error_mark_node;
}
if (!PROTOCOL_FORWARD_DECL (p))
build_protocol_reference (p);
expr = build_unary_op (ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0);
TREE_TYPE (expr) = protocol_type;
/* The @protocol() expression is being compiled into a pointer to a
statically allocated instance of the Protocol class. To become
usable at runtime, the 'isa' pointer of the instance need to be
fixed up at runtime by the runtime library, to point to the
actual 'Protocol' class. */
/* For the GNU runtime, put the static Protocol instance in the list
of statically allocated instances, so that we make sure that its
'isa' pointer is fixed up at runtime by the GNU runtime library
to point to the Protocol class (at runtime, when loading the
module, the GNU runtime library loops on the statically allocated
instances (as found in the defs field in objc_symtab) and fixups
all the 'isa' pointers of those objects). */
if (! flag_next_runtime)
{
/* This type is a struct containing the fields of a Protocol
object. (Cfr. protocol_type instead is the type of a pointer
to such a struct). */
tree protocol_struct_type = xref_tag
(RECORD_TYPE, get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
tree *chain;
/* Look for the list of Protocol statically allocated instances
to fixup at runtime. Create a new list to hold Protocol
statically allocated instances, if the list is not found. At
present there is only another list, holding NSConstantString
static instances to be fixed up at runtime. */
for (chain = &objc_static_instances;
*chain && TREE_VALUE (*chain) != protocol_struct_type;
chain = &TREE_CHAIN (*chain));
if (!*chain)
{
*chain = tree_cons (NULL_TREE, protocol_struct_type, NULL_TREE);
add_objc_string (TYPE_NAME (protocol_struct_type),
class_names);
}
/* Add this statically allocated instance to the Protocol list. */
TREE_PURPOSE (*chain) = tree_cons (NULL_TREE,
PROTOCOL_FORWARD_DECL (p),
TREE_PURPOSE (*chain));
}
return expr;
}
/* This function is called by the parser when a @selector() expression
is found, in order to compile it. It is only called by the parser
and only to compile a @selector(). */
tree
build_selector_expr (selnamelist)
tree selnamelist;
{
tree selname;
/* Obtain the full selector name. */
if (TREE_CODE (selnamelist) == IDENTIFIER_NODE)
/* A unary selector. */
selname = selnamelist;
else if (TREE_CODE (selnamelist) == TREE_LIST)
selname = build_keyword_selector (selnamelist);
else
abort ();
/* If we are required to check @selector() expressions as they
are found, check that the selector has been declared. */
if (warn_undeclared_selector)
{
/* Look the selector up in the list of all known class and
instance methods (up to this line) to check that the selector
exists. */
hash hsh;
/* First try with instance methods. */
hsh = hash_lookup (nst_method_hash_list, selname);
/* If not found, try with class methods. */
if (!hsh)
{
hsh = hash_lookup (cls_method_hash_list, selname);
}
/* If still not found, print out a warning. */
if (!hsh)
{
warning ("undeclared selector `%s'", IDENTIFIER_POINTER (selname));
}
}
if (flag_typed_selectors)
return build_typed_selector_reference (selname, 0);
else
return build_selector_reference (selname);
}
tree
build_encode_expr (type)
tree type;
{
tree result;
const char *string;
encode_type (type, obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
obstack_1grow (&util_obstack, 0); /* null terminate string */
string = obstack_finish (&util_obstack);
/* Synthesize a string that represents the encoded struct/union. */
result = my_build_string (strlen (string) + 1, string);
obstack_free (&util_obstack, util_firstobj);
return result;
}
tree
build_ivar_reference (id)
tree id;
{
if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
{
/* Historically, a class method that produced objects (factory
method) would assign `self' to the instance that it
allocated. This would effectively turn the class method into
an instance method. Following this assignment, the instance
variables could be accessed. That practice, while safe,
violates the simple rule that a class method should not refer
to an instance variable. It's better to catch the cases
where this is done unknowingly than to support the above
paradigm. */
warning ("instance variable `%s' accessed in class method",
IDENTIFIER_POINTER (id));
TREE_TYPE (self_decl) = instance_type; /* cast */
}
return build_component_ref (build_indirect_ref (self_decl, "->"), id);
}
/* Compute a hash value for a given method SEL_NAME. */
static size_t
hash_func (sel_name)
tree sel_name;
{
const unsigned char *s
= (const unsigned char *)IDENTIFIER_POINTER (sel_name);
size_t h = 0;
while (*s)
h = h * 67 + *s++ - 113;
return h;
}
static void
hash_init ()
{
nst_method_hash_list = (hash *) ggc_calloc (SIZEHASHTABLE, sizeof (hash));
cls_method_hash_list = (hash *) ggc_calloc (SIZEHASHTABLE, sizeof (hash));
}
/* WARNING!!!! hash_enter is called with a method, and will peek
inside to find its selector! But hash_lookup is given a selector
directly, and looks for the selector that's inside the found
entry's key (method) for comparison. */
static void
hash_enter (hashlist, method)
hash *hashlist;
tree method;
{
hash obj;
int slot = hash_func (METHOD_SEL_NAME (method)) % SIZEHASHTABLE;
obj = (hash) ggc_alloc (sizeof (struct hashed_entry));
obj->list = 0;
obj->next = hashlist[slot];
obj->key = method;
hashlist[slot] = obj; /* append to front */
}
static hash
hash_lookup (hashlist, sel_name)
hash *hashlist;
tree sel_name;
{
hash target;
target = hashlist[hash_func (sel_name) % SIZEHASHTABLE];
while (target)
{
if (sel_name == METHOD_SEL_NAME (target->key))
return target;
target = target->next;
}
return 0;
}
static void
hash_add_attr (entry, value)
hash entry;
tree value;
{
attr obj;
obj = (attr) ggc_alloc (sizeof (struct hashed_attribute));
obj->next = entry->list;
obj->value = value;
entry->list = obj; /* append to front */
}
static tree
lookup_method (mchain, method)
tree mchain;
tree method;
{
tree key;
if (TREE_CODE (method) == IDENTIFIER_NODE)
key = method;
else
key = METHOD_SEL_NAME (method);
while (mchain)
{
if (METHOD_SEL_NAME (mchain) == key)
return mchain;
mchain = TREE_CHAIN (mchain);
}
return NULL_TREE;
}
static tree
lookup_instance_method_static (interface, ident)
tree interface;
tree ident;
{
tree inter = interface;
tree chain = CLASS_NST_METHODS (inter);
tree meth = NULL_TREE;
do
{
if ((meth = lookup_method (chain, ident)))
return meth;
if (CLASS_CATEGORY_LIST (inter))
{
tree category = CLASS_CATEGORY_LIST (inter);
chain = CLASS_NST_METHODS (category);
do
{
if ((meth = lookup_method (chain, ident)))
return meth;
/* Check for instance methods in protocols in categories. */
if (CLASS_PROTOCOL_LIST (category))
{
if ((meth = (lookup_method_in_protocol_list
(CLASS_PROTOCOL_LIST (category), ident, 0))))
return meth;
}
if ((category = CLASS_CATEGORY_LIST (category)))
chain = CLASS_NST_METHODS (category);
}
while (category);
}
if (CLASS_PROTOCOL_LIST (inter))
{
if ((meth = (lookup_method_in_protocol_list
(CLASS_PROTOCOL_LIST (inter), ident, 0))))
return meth;
}
if ((inter = lookup_interface (CLASS_SUPER_NAME (inter))))
chain = CLASS_NST_METHODS (inter);
}
while (inter);
return meth;
}
static tree
lookup_class_method_static (interface, ident)
tree interface;
tree ident;
{
tree inter = interface;
tree chain = CLASS_CLS_METHODS (inter);
tree meth = NULL_TREE;
tree root_inter = NULL_TREE;
do
{
if ((meth = lookup_method (chain, ident)))
return meth;
if (CLASS_CATEGORY_LIST (inter))
{
tree category = CLASS_CATEGORY_LIST (inter);
chain = CLASS_CLS_METHODS (category);
do
{
if ((meth = lookup_method (chain, ident)))
return meth;
/* Check for class methods in protocols in categories. */
if (CLASS_PROTOCOL_LIST (category))
{
if ((meth = (lookup_method_in_protocol_list
(CLASS_PROTOCOL_LIST (category), ident, 1))))
return meth;
}
if ((category = CLASS_CATEGORY_LIST (category)))
chain = CLASS_CLS_METHODS (category);
}
while (category);
}
/* Check for class methods in protocols. */
if (CLASS_PROTOCOL_LIST (inter))
{
if ((meth = (lookup_method_in_protocol_list
(CLASS_PROTOCOL_LIST (inter), ident, 1))))
return meth;
}
root_inter = inter;
if ((inter = lookup_interface (CLASS_SUPER_NAME (inter))))
chain = CLASS_CLS_METHODS (inter);
}
while (inter);
/* If no class (factory) method was found, check if an _instance_
method of the same name exists in the root class. This is what
the Objective-C runtime will do. */
return lookup_instance_method_static (root_inter, ident);
}
tree
add_class_method (class, method)
tree class;
tree method;
{
tree mth;
hash hsh;
if (!(mth = lookup_method (CLASS_CLS_METHODS (class), method)))
{
/* put method on list in reverse order */
TREE_CHAIN (method) = CLASS_CLS_METHODS (class);
CLASS_CLS_METHODS (class) = method;
}
else
{
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
error ("duplicate definition of class method `%s'",
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
else
{
/* Check types; if different, complain. */
if (!comp_proto_with_proto (method, mth))
error ("duplicate declaration of class method `%s'",
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
}
}
if (!(hsh = hash_lookup (cls_method_hash_list, METHOD_SEL_NAME (method))))
{
/* Install on a global chain. */
hash_enter (cls_method_hash_list, method);
}
else
{
/* Check types; if different, add to a list. */
if (!comp_proto_with_proto (method, hsh->key))
hash_add_attr (hsh, method);
}
return method;
}
tree
add_instance_method (class, method)
tree class;
tree method;
{
tree mth;
hash hsh;
if (!(mth = lookup_method (CLASS_NST_METHODS (class), method)))
{
/* Put method on list in reverse order. */
TREE_CHAIN (method) = CLASS_NST_METHODS (class);
CLASS_NST_METHODS (class) = method;
}
else
{
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
error ("duplicate definition of instance method `%s'",
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
else
{
/* Check types; if different, complain. */
if (!comp_proto_with_proto (method, mth))
error ("duplicate declaration of instance method `%s'",
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
}
}
if (!(hsh = hash_lookup (nst_method_hash_list, METHOD_SEL_NAME (method))))
{
/* Install on a global chain. */
hash_enter (nst_method_hash_list, method);
}
else
{
/* Check types; if different, add to a list. */
if (!comp_proto_with_proto (method, hsh->key))
hash_add_attr (hsh, method);
}
return method;
}
static tree
add_class (class)
tree class;
{
/* Put interfaces on list in reverse order. */
TREE_CHAIN (class) = interface_chain;
interface_chain = class;
return interface_chain;
}
static void
add_category (class, category)
tree class;
tree category;
{
/* Put categories on list in reverse order. */
tree cat = CLASS_CATEGORY_LIST (class);
while (cat)
{
if (CLASS_SUPER_NAME (cat) == CLASS_SUPER_NAME (category))
warning ("duplicate interface declaration for category `%s(%s)'",
IDENTIFIER_POINTER (CLASS_NAME (class)),
IDENTIFIER_POINTER (CLASS_SUPER_NAME (category)));
cat = CLASS_CATEGORY_LIST (cat);
}
CLASS_CATEGORY_LIST (category) = CLASS_CATEGORY_LIST (class);
CLASS_CATEGORY_LIST (class) = category;
}
/* Called after parsing each instance variable declaration. Necessary to
preserve typedefs and implement public/private...
PUBLIC is 1 for public, 0 for protected, and 2 for private. */
tree
add_instance_variable (class, public, declarator, declspecs, width)
tree class;
int public;
tree declarator;
tree declspecs;
tree width;
{
tree field_decl, raw_decl;
raw_decl = build_tree_list (declspecs, declarator);
if (CLASS_RAW_IVARS (class))
chainon (CLASS_RAW_IVARS (class), raw_decl);
else
CLASS_RAW_IVARS (class) = raw_decl;
field_decl = grokfield (input_filename, lineno,
declarator, declspecs, width);
/* Overload the public attribute, it is not used for FIELD_DECLs. */
switch (public)
{
case 0:
TREE_PUBLIC (field_decl) = 0;
TREE_PRIVATE (field_decl) = 0;
TREE_PROTECTED (field_decl) = 1;
break;
case 1:
TREE_PUBLIC (field_decl) = 1;
TREE_PRIVATE (field_decl) = 0;
TREE_PROTECTED (field_decl) = 0;
break;
case 2:
TREE_PUBLIC (field_decl) = 0;
TREE_PRIVATE (field_decl) = 1;
TREE_PROTECTED (field_decl) = 0;
break;
}
if (CLASS_IVARS (class))
chainon (CLASS_IVARS (class), field_decl);
else
CLASS_IVARS (class) = field_decl;
return class;
}
tree
is_ivar (decl_chain, ident)
tree decl_chain;
tree ident;
{
for ( ; decl_chain; decl_chain = TREE_CHAIN (decl_chain))
if (DECL_NAME (decl_chain) == ident)
return decl_chain;
return NULL_TREE;
}
/* True if the ivar is private and we are not in its implementation. */
int
is_private (decl)
tree decl;
{
if (TREE_PRIVATE (decl)
&& ! is_ivar (CLASS_IVARS (implementation_template), DECL_NAME (decl)))
return 1;
else
return 0;
}
/* We have an instance variable reference;, check to see if it is public. */
int
is_public (expr, identifier)
tree expr;
tree identifier;
{
tree basetype = TREE_TYPE (expr);
enum tree_code code = TREE_CODE (basetype);
tree decl;
if (code == RECORD_TYPE)
{
if (TREE_STATIC_TEMPLATE (basetype))
{
if (!lookup_interface (TYPE_NAME (basetype)))
{
error ("cannot find interface declaration for `%s'",
IDENTIFIER_POINTER (TYPE_NAME (basetype)));
return 0;
}
if ((decl = is_ivar (TYPE_FIELDS (basetype), identifier)))
{
if (TREE_PUBLIC (decl))
return 1;
/* Important difference between the Stepstone translator:
all instance variables should be public within the context
of the implementation. */
if (objc_implementation_context
&& (((TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
|| (TREE_CODE (objc_implementation_context)
== CATEGORY_IMPLEMENTATION_TYPE))
&& (CLASS_NAME (objc_implementation_context)
== TYPE_NAME (basetype))))
{
int private = is_private (decl);
if (private)
error ("instance variable '%s' is declared private",
IDENTIFIER_POINTER (DECL_NAME (decl)));
return !private;
}
error ("instance variable `%s' is declared %s",
IDENTIFIER_POINTER (identifier),
TREE_PRIVATE (decl) ? "private" : "protected");
return 0;
}
}
else if (objc_implementation_context && (basetype == objc_object_reference))
{
TREE_TYPE (expr) = uprivate_record;
warning ("static access to object of type `id'");
}
}
return 1;
}
/* Make sure all entries in CHAIN are also in LIST. */
static int
check_methods (chain, list, mtype)
tree chain;
tree list;
int mtype;
{
int first = 1;
while (chain)
{
if (!lookup_method (list, chain))
{
if (first)
{
if (TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
warning ("incomplete implementation of class `%s'",
IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context)));
else if (TREE_CODE (objc_implementation_context)
== CATEGORY_IMPLEMENTATION_TYPE)
warning ("incomplete implementation of category `%s'",
IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)));
first = 0;
}
warning ("method definition for `%c%s' not found",
mtype, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain)));
}
chain = TREE_CHAIN (chain);
}
return first;
}
/* Check if CLASS, or its superclasses, explicitly conforms to PROTOCOL. */
static int
conforms_to_protocol (class, protocol)
tree class;
tree protocol;
{
if (TREE_CODE (protocol) == PROTOCOL_INTERFACE_TYPE)
{
tree p = CLASS_PROTOCOL_LIST (class);
while (p && TREE_VALUE (p) != protocol)
p = TREE_CHAIN (p);
if (!p)
{
tree super = (CLASS_SUPER_NAME (class)
? lookup_interface (CLASS_SUPER_NAME (class))
: NULL_TREE);
int tmp = super ? conforms_to_protocol (super, protocol) : 0;
if (!tmp)
return 0;
}
}
return 1;
}
/* Make sure all methods in CHAIN are accessible as MTYPE methods in
CONTEXT. This is one of two mechanisms to check protocol integrity. */
static int
check_methods_accessible (chain, context, mtype)
tree chain;
tree context;
int mtype;
{
int first = 1;
tree list;
tree base_context = context;
while (chain)
{
context = base_context;
while (context)
{
if (mtype == '+')
list = CLASS_CLS_METHODS (context);
else
list = CLASS_NST_METHODS (context);
if (lookup_method (list, chain))
break;
else if (TREE_CODE (context) == CLASS_IMPLEMENTATION_TYPE
|| TREE_CODE (context) == CLASS_INTERFACE_TYPE)
context = (CLASS_SUPER_NAME (context)
? lookup_interface (CLASS_SUPER_NAME (context))
: NULL_TREE);
else if (TREE_CODE (context) == CATEGORY_IMPLEMENTATION_TYPE
|| TREE_CODE (context) == CATEGORY_INTERFACE_TYPE)
context = (CLASS_NAME (context)
? lookup_interface (CLASS_NAME (context))
: NULL_TREE);
else
abort ();
}
if (context == NULL_TREE)
{
if (first)
{
if (TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
warning ("incomplete implementation of class `%s'",
IDENTIFIER_POINTER
(CLASS_NAME (objc_implementation_context)));
else if (TREE_CODE (objc_implementation_context)
== CATEGORY_IMPLEMENTATION_TYPE)
warning ("incomplete implementation of category `%s'",
IDENTIFIER_POINTER
(CLASS_SUPER_NAME (objc_implementation_context)));
first = 0;
}
warning ("method definition for `%c%s' not found",
mtype, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain)));
}
chain = TREE_CHAIN (chain); /* next method... */
}
return first;
}
/* Check whether the current interface (accessible via
'objc_implementation_context') actually implements protocol P, along
with any protocols that P inherits. */
static void
check_protocol (p, type, name)
tree p;
const char *type;
const char *name;
{
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
int f1, f2;
/* Ensure that all protocols have bodies! */
if (warn_protocol)
{
f1 = check_methods (PROTOCOL_CLS_METHODS (p),
CLASS_CLS_METHODS (objc_implementation_context),
'+');
f2 = check_methods (PROTOCOL_NST_METHODS (p),
CLASS_NST_METHODS (objc_implementation_context),
'-');
}
else
{
f1 = check_methods_accessible (PROTOCOL_CLS_METHODS (p),
objc_implementation_context,
'+');
f2 = check_methods_accessible (PROTOCOL_NST_METHODS (p),
objc_implementation_context,
'-');
}
if (!f1 || !f2)
warning ("%s `%s' does not fully implement the `%s' protocol",
type, name, IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
}
/* Check protocols recursively. */
if (PROTOCOL_LIST (p))
{
tree subs = PROTOCOL_LIST (p);
tree super_class =
lookup_interface (CLASS_SUPER_NAME (implementation_template));
while (subs)
{
tree sub = TREE_VALUE (subs);
/* If the superclass does not conform to the protocols
inherited by P, then we must! */
if (!super_class || !conforms_to_protocol (super_class, sub))
check_protocol (sub, type, name);
subs = TREE_CHAIN (subs);
}
}
}
/* Check whether the current interface (accessible via
'objc_implementation_context') actually implements the protocols listed
in PROTO_LIST. */
static void
check_protocols (proto_list, type, name)
tree proto_list;
const char *type;
const char *name;
{
for ( ; proto_list; proto_list = TREE_CHAIN (proto_list))
{
tree p = TREE_VALUE (proto_list);
check_protocol (p, type, name);
}
}
/* Make sure that the class CLASS_NAME is defined
CODE says which kind of thing CLASS_NAME ought to be.
It can be CLASS_INTERFACE_TYPE, CLASS_IMPLEMENTATION_TYPE,
CATEGORY_INTERFACE_TYPE, or CATEGORY_IMPLEMENTATION_TYPE. */
tree
start_class (code, class_name, super_name, protocol_list)
enum tree_code code;
tree class_name;
tree super_name;
tree protocol_list;
{
tree class, decl;
if (objc_implementation_context)
{
warning ("`@end' missing in implementation context");
finish_class (objc_implementation_context);
objc_ivar_chain = NULL_TREE;
objc_implementation_context = NULL_TREE;
}
class = make_node (code);
TYPE_BINFO (class) = make_tree_vec (6);
CLASS_NAME (class) = class_name;
CLASS_SUPER_NAME (class) = super_name;
CLASS_CLS_METHODS (class) = NULL_TREE;
if (! is_class_name (class_name) && (decl = lookup_name (class_name)))
{
error ("`%s' redeclared as different kind of symbol",
IDENTIFIER_POINTER (class_name));
error_with_decl (decl, "previous declaration of `%s'");
}
if (code == CLASS_IMPLEMENTATION_TYPE)
{
{
tree chain;
for (chain = implemented_classes; chain; chain = TREE_CHAIN (chain))
if (TREE_VALUE (chain) == class_name)
{
error ("reimplementation of class `%s'",
IDENTIFIER_POINTER (class_name));
return error_mark_node;
}
implemented_classes = tree_cons (NULL_TREE, class_name,
implemented_classes);
}
/* Pre-build the following entities - for speed/convenience. */
if (!self_id)
self_id = get_identifier ("self");
if (!ucmd_id)
ucmd_id = get_identifier ("_cmd");
if (!unused_list)
unused_list
= build_tree_list (get_identifier ("__unused__"), NULL_TREE);
if (!objc_super_template)
objc_super_template = build_super_template ();
/* Reset for multiple classes per file. */
method_slot = 0;
objc_implementation_context = class;
/* Lookup the interface for this implementation. */
if (!(implementation_template = lookup_interface (class_name)))
{
warning ("cannot find interface declaration for `%s'",
IDENTIFIER_POINTER (class_name));
add_class (implementation_template = objc_implementation_context);
}
/* If a super class has been specified in the implementation,
insure it conforms to the one specified in the interface. */
if (super_name
&& (super_name != CLASS_SUPER_NAME (implementation_template)))
{
tree previous_name = CLASS_SUPER_NAME (implementation_template);
const char *const name =
previous_name ? IDENTIFIER_POINTER (previous_name) : "";
error ("conflicting super class name `%s'",
IDENTIFIER_POINTER (super_name));
error ("previous declaration of `%s'", name);
}
else if (! super_name)
{
CLASS_SUPER_NAME (objc_implementation_context)
= CLASS_SUPER_NAME (implementation_template);
}
}
else if (code == CLASS_INTERFACE_TYPE)
{
if (lookup_interface (class_name))
warning ("duplicate interface declaration for class `%s'",
IDENTIFIER_POINTER (class_name));
else
add_class (class);
if (protocol_list)
CLASS_PROTOCOL_LIST (class)
= lookup_and_install_protocols (protocol_list);
}
else if (code == CATEGORY_INTERFACE_TYPE)
{
tree class_category_is_assoc_with;
/* For a category, class_name is really the name of the class that
the following set of methods will be associated with. We must
find the interface so that can derive the objects template. */
if (!(class_category_is_assoc_with = lookup_interface (class_name)))
{
error ("cannot find interface declaration for `%s'",
IDENTIFIER_POINTER (class_name));
exit (FATAL_EXIT_CODE);
}
else
add_category (class_category_is_assoc_with, class);
if (protocol_list)
CLASS_PROTOCOL_LIST (class)
= lookup_and_install_protocols (protocol_list);
}
else if (code == CATEGORY_IMPLEMENTATION_TYPE)
{
/* Pre-build the following entities for speed/convenience. */
if (!self_id)
self_id = get_identifier ("self");
if (!ucmd_id)
ucmd_id = get_identifier ("_cmd");
if (!unused_list)
unused_list
= build_tree_list (get_identifier ("__unused__"), NULL_TREE);
if (!objc_super_template)
objc_super_template = build_super_template ();
/* Reset for multiple classes per file. */
method_slot = 0;
objc_implementation_context = class;
/* For a category, class_name is really the name of the class that
the following set of methods will be associated with. We must
find the interface so that can derive the objects template. */
if (!(implementation_template = lookup_interface (class_name)))
{
error ("cannot find interface declaration for `%s'",
IDENTIFIER_POINTER (class_name));
exit (FATAL_EXIT_CODE);
}
}
return class;
}
tree
continue_class (class)
tree class;
{
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE
|| TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE)
{
struct imp_entry *imp_entry;
tree ivar_context;
/* Check consistency of the instance variables. */
if (CLASS_IVARS (class))
check_ivars (implementation_template, class);
/* code generation */
ivar_context = build_private_template (implementation_template);
if (!objc_class_template)
build_class_template ();
imp_entry = (struct imp_entry *) ggc_alloc (sizeof (struct imp_entry));
imp_entry->next = imp_list;
imp_entry->imp_context = class;
imp_entry->imp_template = implementation_template;
synth_forward_declarations ();
imp_entry->class_decl = UOBJC_CLASS_decl;
imp_entry->meta_decl = UOBJC_METACLASS_decl;
/* Append to front and increment count. */
imp_list = imp_entry;
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
imp_count++;
else
cat_count++;
return ivar_context;
}
else if (TREE_CODE (class) == CLASS_INTERFACE_TYPE)
{
tree record = xref_tag (RECORD_TYPE, CLASS_NAME (class));
if (!TYPE_FIELDS (record))
{
finish_struct (record, get_class_ivars (class), NULL_TREE);
CLASS_STATIC_TEMPLATE (class) = record;
/* Mark this record as a class template for static typing. */
TREE_STATIC_TEMPLATE (record) = 1;
}
return NULL_TREE;
}
else
return error_mark_node;
}
/* This is called once we see the "@end" in an interface/implementation. */
void
finish_class (class)
tree class;
{
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
{
/* All code generation is done in finish_objc. */
if (implementation_template != objc_implementation_context)
{
/* Ensure that all method listed in the interface contain bodies. */
check_methods (CLASS_CLS_METHODS (implementation_template),
CLASS_CLS_METHODS (objc_implementation_context), '+');
check_methods (CLASS_NST_METHODS (implementation_template),
CLASS_NST_METHODS (objc_implementation_context), '-');
if (CLASS_PROTOCOL_LIST (implementation_template))
check_protocols (CLASS_PROTOCOL_LIST (implementation_template),
"class",
IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context)));
}
}
else if (TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE)
{
tree category = CLASS_CATEGORY_LIST (implementation_template);
/* Find the category interface from the class it is associated with. */
while (category)
{
if (CLASS_SUPER_NAME (class) == CLASS_SUPER_NAME (category))
break;
category = CLASS_CATEGORY_LIST (category);
}
if (category)
{
/* Ensure all method listed in the interface contain bodies. */
check_methods (CLASS_CLS_METHODS (category),
CLASS_CLS_METHODS (objc_implementation_context), '+');
check_methods (CLASS_NST_METHODS (category),
CLASS_NST_METHODS (objc_implementation_context), '-');
if (CLASS_PROTOCOL_LIST (category))
check_protocols (CLASS_PROTOCOL_LIST (category),
"category",
IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)));
}
}
else if (TREE_CODE (class) == CLASS_INTERFACE_TYPE)
{
tree decl_specs;
const char *class_name = IDENTIFIER_POINTER (CLASS_NAME (class));
char *string = (char *) alloca (strlen (class_name) + 3);
/* extern struct objc_object *_<my_name>; */
sprintf (string, "_%s", class_name);
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]);
decl_specs = tree_cons (NULL_TREE, objc_object_reference, decl_specs);
define_decl (build1 (INDIRECT_REF, NULL_TREE, get_identifier (string)),
decl_specs);
}
}
static tree
add_protocol (protocol)
tree protocol;
{
/* Put protocol on list in reverse order. */
TREE_CHAIN (protocol) = protocol_chain;
protocol_chain = protocol;
return protocol_chain;
}
static tree
lookup_protocol (ident)
tree ident;
{
tree chain;
for (chain = protocol_chain; chain; chain = TREE_CHAIN (chain))
if (ident == PROTOCOL_NAME (chain))
return chain;
return NULL_TREE;
}
/* This function forward declares the protocols named by NAMES. If
they are already declared or defined, the function has no effect. */
void
objc_declare_protocols (names)
tree names;
{
tree list;
for (list = names; list; list = TREE_CHAIN (list))
{
tree name = TREE_VALUE (list);
if (lookup_protocol (name) == NULL_TREE)
{
tree protocol = make_node (PROTOCOL_INTERFACE_TYPE);
TYPE_BINFO (protocol) = make_tree_vec (2);
PROTOCOL_NAME (protocol) = name;
PROTOCOL_LIST (protocol) = NULL_TREE;
add_protocol (protocol);
PROTOCOL_DEFINED (protocol) = 0;
PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
}
}
}
tree
start_protocol (code, name, list)
enum tree_code code;
tree name;
tree list;
{
tree protocol;
/* This is as good a place as any. Need to invoke
push_tag_toplevel. */
if (!objc_protocol_template)
objc_protocol_template = build_protocol_template ();
protocol = lookup_protocol (name);
if (!protocol)
{
protocol = make_node (code);
TYPE_BINFO (protocol) = make_tree_vec (2);
PROTOCOL_NAME (protocol) = name;
PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list);
add_protocol (protocol);
PROTOCOL_DEFINED (protocol) = 1;
PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
check_protocol_recursively (protocol, list);
}
else if (! PROTOCOL_DEFINED (protocol))
{
PROTOCOL_DEFINED (protocol) = 1;
PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list);
check_protocol_recursively (protocol, list);
}
else
{
warning ("duplicate declaration for protocol `%s'",
IDENTIFIER_POINTER (name));
}
return protocol;
}
void
finish_protocol (protocol)
tree protocol ATTRIBUTE_UNUSED;
{
}
/* "Encode" a data type into a string, which grows in util_obstack.
??? What is the FORMAT? Someone please document this! */
static void
encode_type_qualifiers (declspecs)
tree declspecs;
{
tree spec;
for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
{
if (ridpointers[(int) RID_CONST] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'r');
else if (ridpointers[(int) RID_IN] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'n');
else if (ridpointers[(int) RID_INOUT] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'N');
else if (ridpointers[(int) RID_OUT] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'o');
else if (ridpointers[(int) RID_BYCOPY] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'O');
else if (ridpointers[(int) RID_BYREF] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'R');
else if (ridpointers[(int) RID_ONEWAY] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'V');
}
}
/* Encode a pointer type. */
static void
encode_pointer (type, curtype, format)
tree type;
int curtype;
int format;
{
tree pointer_to = TREE_TYPE (type);
if (TREE_CODE (pointer_to) == RECORD_TYPE)
{
if (TYPE_NAME (pointer_to)
&& TREE_CODE (TYPE_NAME (pointer_to)) == IDENTIFIER_NODE)
{
const char *name = IDENTIFIER_POINTER (TYPE_NAME (pointer_to));
if (strcmp (name, TAG_OBJECT) == 0) /* '@' */
{
obstack_1grow (&util_obstack, '@');
return;
}
else if (TREE_STATIC_TEMPLATE (pointer_to))
{
if (generating_instance_variables)
{
obstack_1grow (&util_obstack, '@');
obstack_1grow (&util_obstack, '"');
obstack_grow (&util_obstack, name, strlen (name));
obstack_1grow (&util_obstack, '"');
return;
}
else
{
obstack_1grow (&util_obstack, '@');
return;
}
}
else if (strcmp (name, TAG_CLASS) == 0) /* '#' */
{
obstack_1grow (&util_obstack, '#');
return;
}
else if (strcmp (name, TAG_SELECTOR) == 0) /* ':' */
{
obstack_1grow (&util_obstack, ':');
return;
}
}
}
else if (TREE_CODE (pointer_to) == INTEGER_TYPE
&& TYPE_MODE (pointer_to) == QImode)
{
obstack_1grow (&util_obstack, '*');
return;
}
/* We have a type that does not get special treatment. */
/* NeXT extension */
obstack_1grow (&util_obstack, '^');
encode_type (pointer_to, curtype, format);
}
static void
encode_array (type, curtype, format)
tree type;
int curtype;
int format;
{
tree an_int_cst = TYPE_SIZE (type);
tree array_of = TREE_TYPE (type);
char buffer[40];
/* An incomplete array is treated like a pointer. */
if (an_int_cst == NULL)
{
encode_pointer (type, curtype, format);
return;
}
sprintf (buffer, "[%ld",
(long) (TREE_INT_CST_LOW (an_int_cst)
/ TREE_INT_CST_LOW (TYPE_SIZE (array_of))));
obstack_grow (&util_obstack, buffer, strlen (buffer));
encode_type (array_of, curtype, format);
obstack_1grow (&util_obstack, ']');
return;
}
static void
encode_aggregate_within (type, curtype, format, left, right)
tree type;
int curtype;
int format;
int left;
int right;
{
/* The RECORD_TYPE may in fact be a typedef! For purposes
of encoding, we need the real underlying enchilada. */
if (TYPE_MAIN_VARIANT (type))
type = TYPE_MAIN_VARIANT (type);
if (obstack_object_size (&util_obstack) > 0
&& *(obstack_next_free (&util_obstack) - 1) == '^')
{
tree name = TYPE_NAME (type);
/* we have a reference; this is a NeXT extension. */
if (obstack_object_size (&util_obstack) - curtype == 1
&& format == OBJC_ENCODE_INLINE_DEFS)
{
/* Output format of struct for first level only. */
tree fields = TYPE_FIELDS (type);
if (name && TREE_CODE (name) == IDENTIFIER_NODE)
{
obstack_1grow (&util_obstack, left);
obstack_grow (&util_obstack,
IDENTIFIER_POINTER (name),
strlen (IDENTIFIER_POINTER (name)));
obstack_1grow (&util_obstack, '=');
}
else
{
obstack_1grow (&util_obstack, left);
obstack_grow (&util_obstack, "?=", 2);
}
for ( ; fields; fields = TREE_CHAIN (fields))
encode_field_decl (fields, curtype, format);
obstack_1grow (&util_obstack, right);
}
else if (name && TREE_CODE (name) == IDENTIFIER_NODE)
{
obstack_1grow (&util_obstack, left);
obstack_grow (&util_obstack,
IDENTIFIER_POINTER (name),
strlen (IDENTIFIER_POINTER (name)));
obstack_1grow (&util_obstack, right);
}
else
{
/* We have an untagged structure or a typedef. */
obstack_1grow (&util_obstack, left);
obstack_1grow (&util_obstack, '?');
obstack_1grow (&util_obstack, right);
}
}
else
{
tree name = TYPE_NAME (type);
tree fields = TYPE_FIELDS (type);
if (format == OBJC_ENCODE_INLINE_DEFS
|| generating_instance_variables)
{
obstack_1grow (&util_obstack, left);
if (name && TREE_CODE (name) == IDENTIFIER_NODE)
obstack_grow (&util_obstack,
IDENTIFIER_POINTER (name),
strlen (IDENTIFIER_POINTER (name)));
else
obstack_1grow (&util_obstack, '?');
obstack_1grow (&util_obstack, '=');
for (; fields; fields = TREE_CHAIN (fields))
{
if (generating_instance_variables)
{
tree fname = DECL_NAME (fields);
obstack_1grow (&util_obstack, '"');
if (fname && TREE_CODE (fname) == IDENTIFIER_NODE)
{
obstack_grow (&util_obstack,
IDENTIFIER_POINTER (fname),
strlen (IDENTIFIER_POINTER (fname)));
}
obstack_1grow (&util_obstack, '"');
}
encode_field_decl (fields, curtype, format);
}
obstack_1grow (&util_obstack, right);
}
else
{
obstack_1grow (&util_obstack, left);
if (name && TREE_CODE (name) == IDENTIFIER_NODE)
obstack_grow (&util_obstack,
IDENTIFIER_POINTER (name),
strlen (IDENTIFIER_POINTER (name)));
else
/* We have an untagged structure or a typedef. */
obstack_1grow (&util_obstack, '?');
obstack_1grow (&util_obstack, right);
}
}
}
static void
encode_aggregate (type, curtype, format)
tree type;
int curtype;
int format;
{
enum tree_code code = TREE_CODE (type);
switch (code)
{
case RECORD_TYPE:
{
encode_aggregate_within(type, curtype, format, '{', '}');
break;
}
case UNION_TYPE:
{
encode_aggregate_within(type, curtype, format, '(', ')');
break;
}
case ENUMERAL_TYPE:
obstack_1grow (&util_obstack, 'i');
break;
default:
break;
}
}
/* Support bitfields. The current version of Objective-C does not support
them. The string will consist of one or more "b:n"'s where n is an
integer describing the width of the bitfield. Currently, classes in
the kit implement a method "-(char *)describeBitfieldStruct:" that
simulates this. If they do not implement this method, the archiver
assumes the bitfield is 16 bits wide (padded if necessary) and packed
according to the GNU compiler. After looking at the "kit", it appears
that all classes currently rely on this default behavior, rather than
hand generating this string (which is tedious). */
static void
encode_bitfield (width)
int width;
{
char buffer[40];
sprintf (buffer, "b%d", width);
obstack_grow (&util_obstack, buffer, strlen (buffer));
}
/* FORMAT will be OBJC_ENCODE_INLINE_DEFS or OBJC_ENCODE_DONT_INLINE_DEFS. */
static void
encode_type (type, curtype, format)
tree type;
int curtype;
int format;
{
enum tree_code code = TREE_CODE (type);
if (code == INTEGER_TYPE)
{
if (integer_zerop (TYPE_MIN_VALUE (type)))
{
/* Unsigned integer types. */
if (TYPE_MODE (type) == QImode)
obstack_1grow (&util_obstack, 'C');
else if (TYPE_MODE (type) == HImode)
obstack_1grow (&util_obstack, 'S');
else if (TYPE_MODE (type) == SImode)
{
if (type == long_unsigned_type_node)
obstack_1grow (&util_obstack, 'L');
else
obstack_1grow (&util_obstack, 'I');
}
else if (TYPE_MODE (type) == DImode)
obstack_1grow (&util_obstack, 'Q');
}
else
/* Signed integer types. */
{
if (TYPE_MODE (type) == QImode)
obstack_1grow (&util_obstack, 'c');
else if (TYPE_MODE (type) == HImode)
obstack_1grow (&util_obstack, 's');
else if (TYPE_MODE (type) == SImode)
{
if (type == long_integer_type_node)
obstack_1grow (&util_obstack, 'l');
else
obstack_1grow (&util_obstack, 'i');
}
else if (TYPE_MODE (type) == DImode)
obstack_1grow (&util_obstack, 'q');
}
}
else if (code == REAL_TYPE)
{
/* Floating point types. */
if (TYPE_MODE (type) == SFmode)
obstack_1grow (&util_obstack, 'f');
else if (TYPE_MODE (type) == DFmode
|| TYPE_MODE (type) == TFmode)
obstack_1grow (&util_obstack, 'd');
}
else if (code == VOID_TYPE)
obstack_1grow (&util_obstack, 'v');
else if (code == ARRAY_TYPE)
encode_array (type, curtype, format);
else if (code == POINTER_TYPE)
encode_pointer (type, curtype, format);
else if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
encode_aggregate (type, curtype, format);
else if (code == FUNCTION_TYPE) /* '?' */
obstack_1grow (&util_obstack, '?');
}
static void
encode_complete_bitfield (position, type, size)
int position;
tree type;
int size;
{
enum tree_code code = TREE_CODE (type);
char buffer[40];
char charType = '?';
if (code == INTEGER_TYPE)
{
if (integer_zerop (TYPE_MIN_VALUE (type)))
{
/* Unsigned integer types. */
if (TYPE_MODE (type) == QImode)
charType = 'C';
else if (TYPE_MODE (type) == HImode)
charType = 'S';
else if (TYPE_MODE (type) == SImode)
{
if (type == long_unsigned_type_node)
charType = 'L';
else
charType = 'I';
}
else if (TYPE_MODE (type) == DImode)
charType = 'Q';
}
else
/* Signed integer types. */
{
if (TYPE_MODE (type) == QImode)
charType = 'c';
else if (TYPE_MODE (type) == HImode)
charType = 's';
else if (TYPE_MODE (type) == SImode)
{
if (type == long_integer_type_node)
charType = 'l';
else
charType = 'i';
}
else if (TYPE_MODE (type) == DImode)
charType = 'q';
}
}
else if (code == ENUMERAL_TYPE)
charType = 'i';
else
abort ();
sprintf (buffer, "b%d%c%d", position, charType, size);
obstack_grow (&util_obstack, buffer, strlen (buffer));
}
static void
encode_field_decl (field_decl, curtype, format)
tree field_decl;
int curtype;
int format;
{
tree type;
type = TREE_TYPE (field_decl);
/* If this field is obviously a bitfield, or is a bitfield that has been
clobbered to look like a ordinary integer mode, go ahead and generate
the bitfield typing information. */
if (flag_next_runtime)
{
if (DECL_BIT_FIELD_TYPE (field_decl))
encode_bitfield (tree_low_cst (DECL_SIZE (field_decl), 1));
else
encode_type (TREE_TYPE (field_decl), curtype, format);
}
else
{
if (DECL_BIT_FIELD_TYPE (field_decl))
encode_complete_bitfield (int_bit_position (field_decl),
DECL_BIT_FIELD_TYPE (field_decl),
tree_low_cst (DECL_SIZE (field_decl), 1));
else
encode_type (TREE_TYPE (field_decl), curtype, format);
}
}
static tree
expr_last (complex_expr)
tree complex_expr;
{
tree next;
if (complex_expr)
while ((next = TREE_OPERAND (complex_expr, 0)))
complex_expr = next;
return complex_expr;
}
/* Transform a method definition into a function definition as follows:
- synthesize the first two arguments, "self" and "_cmd". */
void
start_method_def (method)
tree method;
{
tree decl_specs;
/* Required to implement _msgSuper. */
objc_method_context = method;
UOBJC_SUPER_decl = NULL_TREE;
/* Must be called BEFORE start_function. */
pushlevel (0);
/* Generate prototype declarations for arguments..."new-style". */
if (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL)
decl_specs = build_tree_list (NULL_TREE, uprivate_record);
else
/* Really a `struct objc_class *'. However, we allow people to
assign to self, which changes its type midstream. */
decl_specs = build_tree_list (NULL_TREE, objc_object_reference);
push_parm_decl (build_tree_list
(build_tree_list (decl_specs,
build1 (INDIRECT_REF, NULL_TREE, self_id)),
unused_list));
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)));
push_parm_decl (build_tree_list
(build_tree_list (decl_specs,
build1 (INDIRECT_REF, NULL_TREE, ucmd_id)),
unused_list));
/* Generate argument declarations if a keyword_decl. */
if (METHOD_SEL_ARGS (method))
{
tree arglist = METHOD_SEL_ARGS (method);
do
{
tree arg_spec = TREE_PURPOSE (TREE_TYPE (arglist));
tree arg_decl = TREE_VALUE (TREE_TYPE (arglist));
if (arg_decl)
{
tree last_expr = expr_last (arg_decl);
/* Unite the abstract decl with its name. */
TREE_OPERAND (last_expr, 0) = KEYWORD_ARG_NAME (arglist);
push_parm_decl (build_tree_list
(build_tree_list (arg_spec, arg_decl),
NULL_TREE));
/* Unhook: restore the abstract declarator. */
TREE_OPERAND (last_expr, 0) = NULL_TREE;
}
else
push_parm_decl (build_tree_list
(build_tree_list (arg_spec,
KEYWORD_ARG_NAME (arglist)),
NULL_TREE));
arglist = TREE_CHAIN (arglist);
}
while (arglist);
}
if (METHOD_ADD_ARGS (method) != NULL_TREE
&& METHOD_ADD_ARGS (method) != objc_ellipsis_node)
{
/* We have a variable length selector - in "prototype" format. */
tree akey = TREE_PURPOSE (METHOD_ADD_ARGS (method));
while (akey)
{
/* This must be done prior to calling pushdecl. pushdecl is
going to change our chain on us. */
tree nextkey = TREE_CHAIN (akey);
pushdecl (akey);
akey = nextkey;
}
}
}
static void
warn_with_method (message, mtype, method)
const char *message;
int mtype;
tree method;
{
if (!diagnostic_count_diagnostic (global_dc, DK_WARNING))
return;
diagnostic_report_current_function (global_dc);
/* Add a readable method name to the warning. */
warning_with_file_and_line (DECL_SOURCE_FILE (method),
DECL_SOURCE_LINE (method),
"%s `%c%s'",
message, mtype,
gen_method_decl (method, errbuf));
}
/* Return 1 if METHOD is consistent with PROTO. */
static int
comp_method_with_proto (method, proto)
tree method, proto;
{
/* Create a function template node at most once. */
if (!function1_template)
function1_template = make_node (FUNCTION_TYPE);
/* Install argument types - normally set by build_function_type. */
TYPE_ARG_TYPES (function1_template) = get_arg_type_list (proto, METHOD_DEF, 0);
/* install return type */
TREE_TYPE (function1_template) = groktypename (TREE_TYPE (proto));
return comptypes (TREE_TYPE (METHOD_DEFINITION (method)), function1_template);
}
/* Return 1 if PROTO1 is consistent with PROTO2. */
static int
comp_proto_with_proto (proto0, proto1)
tree proto0, proto1;
{
/* Create a couple of function_template nodes at most once. */
if (!function1_template)
function1_template = make_node (FUNCTION_TYPE);
if (!function2_template)
function2_template = make_node (FUNCTION_TYPE);
/* Install argument types; normally set by build_function_type. */
TYPE_ARG_TYPES (function1_template) = get_arg_type_list (proto0, METHOD_REF, 0);
TYPE_ARG_TYPES (function2_template) = get_arg_type_list (proto1, METHOD_REF, 0);
/* Install return type. */
TREE_TYPE (function1_template) = groktypename (TREE_TYPE (proto0));
TREE_TYPE (function2_template) = groktypename (TREE_TYPE (proto1));
return comptypes (function1_template, function2_template);
}
/* - Generate an identifier for the function. the format is "_n_cls",
where 1 <= n <= nMethods, and cls is the name the implementation we
are processing.
- Install the return type from the method declaration.
- If we have a prototype, check for type consistency. */
static void
really_start_method (method, parmlist)
tree method, parmlist;
{
tree sc_spec, ret_spec, ret_decl, decl_specs;
tree method_decl, method_id;
const char *sel_name, *class_name, *cat_name;
char *buf;
/* Synth the storage class & assemble the return type. */
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
ret_spec = TREE_PURPOSE (TREE_TYPE (method));
decl_specs = chainon (sc_spec, ret_spec);
sel_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method));
class_name = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
cat_name = ((TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
? NULL
: IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)));
method_slot++;
/* Make sure this is big enough for any plausible method label. */
buf = (char *) alloca (50 + strlen (sel_name) + strlen (class_name)
+ (cat_name ? strlen (cat_name) : 0));
OBJC_GEN_METHOD_LABEL (buf, TREE_CODE (method) == INSTANCE_METHOD_DECL,
class_name, cat_name, sel_name, method_slot);
method_id = get_identifier (buf);
method_decl = build_nt (CALL_EXPR, method_id, parmlist, NULL_TREE);
/* Check the declarator portion of the return type for the method. */
if ((ret_decl = TREE_VALUE (TREE_TYPE (method))))
{
/* Unite the complex decl (specified in the abstract decl) with the
function decl just synthesized..(int *), (int (*)()), (int (*)[]). */
tree save_expr = expr_last (ret_decl);
TREE_OPERAND (save_expr, 0) = method_decl;
method_decl = ret_decl;
/* Fool the parser into thinking it is starting a function. */
start_function (decl_specs, method_decl, NULL_TREE);
/* Unhook: this has the effect of restoring the abstract declarator. */
TREE_OPERAND (save_expr, 0) = NULL_TREE;
}
else
{
TREE_VALUE (TREE_TYPE (method)) = method_decl;
/* Fool the parser into thinking it is starting a function. */
start_function (decl_specs, method_decl, NULL_TREE);
/* Unhook: this has the effect of restoring the abstract declarator. */
TREE_VALUE (TREE_TYPE (method)) = NULL_TREE;
}
METHOD_DEFINITION (method) = current_function_decl;
/* Check consistency...start_function, pushdecl, duplicate_decls. */
if (implementation_template != objc_implementation_context)
{
tree proto;
if (TREE_CODE (method) == INSTANCE_METHOD_DECL)
proto = lookup_instance_method_static (implementation_template,
METHOD_SEL_NAME (method));
else
proto = lookup_class_method_static (implementation_template,
METHOD_SEL_NAME (method));
if (proto && ! comp_method_with_proto (method, proto))
{
char type = (TREE_CODE (method) == INSTANCE_METHOD_DECL ? '-' : '+');
warn_with_method ("conflicting types for", type, method);
warn_with_method ("previous declaration of", type, proto);
}
}
}
/* The following routine is always called...this "architecture" is to
accommodate "old-style" variable length selectors.
- a:a b:b // prototype ; id c; id d; // old-style. */
void
continue_method_def ()
{
tree parmlist;
if (METHOD_ADD_ARGS (objc_method_context) == objc_ellipsis_node)
/* We have a `, ...' immediately following the selector. */
parmlist = get_parm_info (0);
else
parmlist = get_parm_info (1); /* place a `void_at_end' */
/* Set self_decl from the first argument...this global is used by
build_ivar_reference calling build_indirect_ref. */
self_decl = TREE_PURPOSE (parmlist);
poplevel (0, 0, 0);
really_start_method (objc_method_context, parmlist);
store_parm_decls ();
}
/* Called by the parser, from the `pushlevel' production. */
void
add_objc_decls ()
{
if (!UOBJC_SUPER_decl)
{
UOBJC_SUPER_decl = start_decl (get_identifier (UTAG_SUPER),
build_tree_list (NULL_TREE,
objc_super_template),
0, NULL_TREE);
finish_decl (UOBJC_SUPER_decl, NULL_TREE, NULL_TREE);
/* This prevents `unused variable' warnings when compiling with -Wall. */
TREE_USED (UOBJC_SUPER_decl) = 1;
DECL_ARTIFICIAL (UOBJC_SUPER_decl) = 1;
}
}
/* _n_Method (id self, SEL sel, ...)
{
struct objc_super _S;
_msgSuper ((_S.self = self, _S.class = _cls, &_S), ...);
} */
tree
get_super_receiver ()
{
if (objc_method_context)
{
tree super_expr, super_expr_list;
/* Set receiver to self. */
super_expr = build_component_ref (UOBJC_SUPER_decl, self_id);
super_expr = build_modify_expr (super_expr, NOP_EXPR, self_decl);
super_expr_list = build_tree_list (NULL_TREE, super_expr);
/* Set class to begin searching. */
super_expr = build_component_ref (UOBJC_SUPER_decl,
get_identifier ("class"));
if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
{
/* [_cls, __cls]Super are "pre-built" in
synth_forward_declarations. */
super_expr = build_modify_expr (super_expr, NOP_EXPR,
((TREE_CODE (objc_method_context)
== INSTANCE_METHOD_DECL)
? ucls_super_ref
: uucls_super_ref));
}
else
/* We have a category. */
{
tree super_name = CLASS_SUPER_NAME (implementation_template);
tree super_class;
/* Barf if super used in a category of Object. */
if (!super_name)
{
error ("no super class declared in interface for `%s'",
IDENTIFIER_POINTER (CLASS_NAME (implementation_template)));
return error_mark_node;
}
if (flag_next_runtime)
{
super_class = get_class_reference (super_name);
if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
/* Cast the super class to 'id', since the user may not have
included <objc/objc-class.h>, leaving 'struct objc_class'
an incomplete type. */
super_class
= build_component_ref (build_indirect_ref
(build_c_cast (id_type, super_class), "->"),
get_identifier ("isa"));
}
else
{
add_class_reference (super_name);
super_class = (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL
? objc_get_class_decl : objc_get_meta_class_decl);
assemble_external (super_class);
super_class
= build_function_call
(super_class,
build_tree_list
(NULL_TREE,
my_build_string (IDENTIFIER_LENGTH (super_name) + 1,
IDENTIFIER_POINTER (super_name))));
}
TREE_TYPE (super_class) = TREE_TYPE (ucls_super_ref);
super_expr = build_modify_expr (super_expr, NOP_EXPR, super_class);
}
chainon (super_expr_list, build_tree_list (NULL_TREE, super_expr));
super_expr = build_unary_op (ADDR_EXPR, UOBJC_SUPER_decl, 0);
chainon (super_expr_list, build_tree_list (NULL_TREE, super_expr));
return build_compound_expr (super_expr_list);
}
else
{
error ("[super ...] must appear in a method context");
return error_mark_node;
}
}
static tree
encode_method_def (func_decl)
tree func_decl;
{
tree parms;
int stack_size;
HOST_WIDE_INT max_parm_end = 0;
char buffer[40];
tree result;
/* Return type. */
encode_type (TREE_TYPE (TREE_TYPE (func_decl)),
obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
/* Stack size. */
for (parms = DECL_ARGUMENTS (func_decl); parms;
parms = TREE_CHAIN (parms))
{
HOST_WIDE_INT parm_end = (forwarding_offset (parms)
+ int_size_in_bytes (TREE_TYPE (parms)));
if (! offset_is_register && parm_end > max_parm_end)
max_parm_end = parm_end;
}
stack_size = max_parm_end - OBJC_FORWARDING_MIN_OFFSET;
sprintf (buffer, "%d", stack_size);
obstack_grow (&util_obstack, buffer, strlen (buffer));
/* Argument types. */
for (parms = DECL_ARGUMENTS (func_decl); parms;
parms = TREE_CHAIN (parms))
{
/* Type. */
encode_type (TREE_TYPE (parms),
obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
/* Compute offset. */
sprintf (buffer, "%d", forwarding_offset (parms));
/* Indicate register. */
if (offset_is_register)
obstack_1grow (&util_obstack, '+');
obstack_grow (&util_obstack, buffer, strlen (buffer));
}
/* Null terminate string. */
obstack_1grow (&util_obstack, 0);
result = get_identifier (obstack_finish (&util_obstack));
obstack_free (&util_obstack, util_firstobj);
return result;
}
static void
objc_expand_function_end ()
{
METHOD_ENCODING (objc_method_context) = encode_method_def (current_function_decl);
}
void
finish_method_def ()
{
lang_expand_function_end = objc_expand_function_end;
finish_function (0, 1);
lang_expand_function_end = NULL;
/* Required to implement _msgSuper. This must be done AFTER finish_function,
since the optimizer may find "may be used before set" errors. */
objc_method_context = NULL_TREE;
}
#if 0
int
lang_report_error_function (decl)
tree decl;
{
if (objc_method_context)
{
fprintf (stderr, "In method `%s'\n",
IDENTIFIER_POINTER (METHOD_SEL_NAME (objc_method_context)));
return 1;
}
else
return 0;
}
#endif
static int
is_complex_decl (type)
tree type;
{
return (TREE_CODE (type) == ARRAY_TYPE
|| TREE_CODE (type) == FUNCTION_TYPE
|| (TREE_CODE (type) == POINTER_TYPE && ! IS_ID (type)));
}
/* Code to convert a decl node into text for a declaration in C. */
static char tmpbuf[256];
static void
adorn_decl (decl, str)
tree decl;
char *str;
{
enum tree_code code = TREE_CODE (decl);
if (code == ARRAY_REF)
{
tree an_int_cst = TREE_OPERAND (decl, 1);
if (an_int_cst && TREE_CODE (an_int_cst) == INTEGER_CST)
sprintf (str + strlen (str), "[%ld]",
(long) TREE_INT_CST_LOW (an_int_cst));
else
strcat (str, "[]");
}
else if (code == ARRAY_TYPE)
{
tree an_int_cst = TYPE_SIZE (decl);
tree array_of = TREE_TYPE (decl);
if (an_int_cst && TREE_CODE (an_int_cst) == INTEGER_TYPE)
sprintf (str + strlen (str), "[%ld]",
(long) (TREE_INT_CST_LOW (an_int_cst)
/ TREE_INT_CST_LOW (TYPE_SIZE (array_of))));
else
strcat (str, "[]");
}
else if (code == CALL_EXPR)
{
tree chain = TREE_PURPOSE (TREE_OPERAND (decl, 1));
strcat (str, "(");
while (chain)
{
gen_declaration_1 (chain, str);
chain = TREE_CHAIN (chain);
if (chain)
strcat (str, ", ");
}
strcat (str, ")");
}
else if (code == FUNCTION_TYPE)
{
tree chain = TYPE_ARG_TYPES (decl);
strcat (str, "(");
while (chain && TREE_VALUE (chain) != void_type_node)
{
gen_declaration_1 (TREE_VALUE (chain), str);
chain = TREE_CHAIN (chain);
if (chain && TREE_VALUE (chain) != void_type_node)
strcat (str, ", ");
}
strcat (str, ")");
}
else if (code == INDIRECT_REF)
{
strcpy (tmpbuf, "*");
if (TREE_TYPE (decl) && TREE_CODE (TREE_TYPE (decl)) == TREE_LIST)
{
tree chain;
for (chain = nreverse (copy_list (TREE_TYPE (decl)));
chain;
chain = TREE_CHAIN (chain))
{
if (TREE_CODE (TREE_VALUE (chain)) == IDENTIFIER_NODE)
{
strcat (tmpbuf, " ");
strcat (tmpbuf, IDENTIFIER_POINTER (TREE_VALUE (chain)));
}
}
if (str[0])
strcat (tmpbuf, " ");
}
strcat (tmpbuf, str);
strcpy (str, tmpbuf);
}
else if (code == POINTER_TYPE)
{
strcpy (tmpbuf, "*");
if (TREE_READONLY (decl) || TYPE_VOLATILE (decl))
{
if (TREE_READONLY (decl))
strcat (tmpbuf, " const");
if (TYPE_VOLATILE (decl))
strcat (tmpbuf, " volatile");
if (str[0])
strcat (tmpbuf, " ");
}
strcat (tmpbuf, str);
strcpy (str, tmpbuf);
}
}
static char *
gen_declarator (decl, buf, name)
tree decl;
char *buf;
const char *name;
{
if (decl)
{
enum tree_code code = TREE_CODE (decl);
char *str;
tree op;
int wrap = 0;
switch (code)
{
case ARRAY_REF:
case INDIRECT_REF:
case CALL_EXPR:
op = TREE_OPERAND (decl, 0);
/* We have a pointer to a function or array...(*)(), (*)[] */
if ((code == ARRAY_REF || code == CALL_EXPR)
&& op && TREE_CODE (op) == INDIRECT_REF)
wrap = 1;
str = gen_declarator (op, buf, name);
if (wrap)
{
strcpy (tmpbuf, "(");
strcat (tmpbuf, str);
strcat (tmpbuf, ")");
strcpy (str, tmpbuf);
}
adorn_decl (decl, str);
break;
case ARRAY_TYPE:
case FUNCTION_TYPE:
case POINTER_TYPE:
strcpy (buf, name);
str = buf;
/* This clause is done iteratively rather than recursively. */
do
{
op = (is_complex_decl (TREE_TYPE (decl))
? TREE_TYPE (decl) : NULL_TREE);
adorn_decl (decl, str);
/* We have a pointer to a function or array...(*)(), (*)[] */
if (code == POINTER_TYPE
&& op && (TREE_CODE (op) == FUNCTION_TYPE
|| TREE_CODE (op) == ARRAY_TYPE))
{
strcpy (tmpbuf, "(");
strcat (tmpbuf, str);
strcat (tmpbuf, ")");
strcpy (str, tmpbuf);
}
decl = (is_complex_decl (TREE_TYPE (decl))
? TREE_TYPE (decl) : NULL_TREE);
}
while (decl && (code = TREE_CODE (decl)))
;
break;
case IDENTIFIER_NODE:
/* Will only happen if we are processing a "raw" expr-decl. */
strcpy (buf, IDENTIFIER_POINTER (decl));
return buf;
default:
abort ();
}
return str;
}
else
/* We have an abstract declarator or a _DECL node. */
{
strcpy (buf, name);
return buf;
}
}
static void
gen_declspecs (declspecs, buf, raw)
tree declspecs;
char *buf;
int raw;
{
if (raw)
{
tree chain;
for (chain = nreverse (copy_list (declspecs));
chain; chain = TREE_CHAIN (chain))
{
tree aspec = TREE_VALUE (chain);
if (TREE_CODE (aspec) == IDENTIFIER_NODE)
strcat (buf, IDENTIFIER_POINTER (aspec));
else if (TREE_CODE (aspec) == RECORD_TYPE)
{
if (TYPE_NAME (aspec))
{
tree protocol_list = TYPE_PROTOCOL_LIST (aspec);
if (! TREE_STATIC_TEMPLATE (aspec))
strcat (buf, "struct ");
strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (aspec)));
/* NEW!!! */
if (protocol_list)
{
tree chain = protocol_list;
strcat (buf, " <");
while (chain)
{
strcat (buf,
IDENTIFIER_POINTER
(PROTOCOL_NAME (TREE_VALUE (chain))));
chain = TREE_CHAIN (chain);
if (chain)
strcat (buf, ", ");
}
strcat (buf, ">");
}
}
else
strcat (buf, "untagged struct");
}
else if (TREE_CODE (aspec) == UNION_TYPE)
{
if (TYPE_NAME (aspec))
{
if (! TREE_STATIC_TEMPLATE (aspec))
strcat (buf, "union ");
strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (aspec)));
}
else
strcat (buf, "untagged union");
}
else if (TREE_CODE (aspec) == ENUMERAL_TYPE)
{
if (TYPE_NAME (aspec))
{
if (! TREE_STATIC_TEMPLATE (aspec))
strcat (buf, "enum ");
strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (aspec)));
}
else
strcat (buf, "untagged enum");
}
else if (TREE_CODE (aspec) == TYPE_DECL && DECL_NAME (aspec))
strcat (buf, IDENTIFIER_POINTER (DECL_NAME (aspec)));
else if (IS_ID (aspec))
{
tree protocol_list = TYPE_PROTOCOL_LIST (aspec);
strcat (buf, "id");
if (protocol_list)
{
tree chain = protocol_list;
strcat (buf, " <");
while (chain)
{
strcat (buf,
IDENTIFIER_POINTER
(PROTOCOL_NAME (TREE_VALUE (chain))));
chain = TREE_CHAIN (chain);
if (chain)
strcat (buf, ", ");
}
strcat (buf, ">");
}
}
if (TREE_CHAIN (chain))
strcat (buf, " ");
}
}
else
{
/* Type qualifiers. */
if (TREE_READONLY (declspecs))
strcat (buf, "const ");
if (TYPE_VOLATILE (declspecs))
strcat (buf, "volatile ");
switch (TREE_CODE (declspecs))
{
/* Type specifiers. */
case INTEGER_TYPE:
declspecs = TYPE_MAIN_VARIANT (declspecs);
/* Signed integer types. */
if (declspecs == short_integer_type_node)
strcat (buf, "short int ");
else if (declspecs == integer_type_node)
strcat (buf, "int ");
else if (declspecs == long_integer_type_node)
strcat (buf, "long int ");
else if (declspecs == long_long_integer_type_node)
strcat (buf, "long long int ");
else if (declspecs == signed_char_type_node
|| declspecs == char_type_node)
strcat (buf, "char ");
/* Unsigned integer types. */
else if (declspecs == short_unsigned_type_node)
strcat (buf, "unsigned short ");
else if (declspecs == unsigned_type_node)
strcat (buf, "unsigned int ");
else if (declspecs == long_unsigned_type_node)
strcat (buf, "unsigned long ");
else if (declspecs == long_long_unsigned_type_node)
strcat (buf, "unsigned long long ");
else if (declspecs == unsigned_char_type_node)
strcat (buf, "unsigned char ");
break;
case REAL_TYPE:
declspecs = TYPE_MAIN_VARIANT (declspecs);
if (declspecs == float_type_node)
strcat (buf, "float ");
else if (declspecs == double_type_node)
strcat (buf, "double ");
else if (declspecs == long_double_type_node)
strcat (buf, "long double ");
break;
case RECORD_TYPE:
if (TYPE_NAME (declspecs)
&& TREE_CODE (TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
{
tree protocol_list = TYPE_PROTOCOL_LIST (declspecs);
if (! TREE_STATIC_TEMPLATE (declspecs))
strcat (buf, "struct ");
strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (declspecs)));
if (protocol_list)
{
tree chain = protocol_list;
strcat (buf, " <");
while (chain)
{
strcat (buf,
IDENTIFIER_POINTER
(PROTOCOL_NAME (TREE_VALUE (chain))));
chain = TREE_CHAIN (chain);
if (chain)
strcat (buf, ", ");
}
strcat (buf, ">");
}
}
else
strcat (buf, "untagged struct");
strcat (buf, " ");
break;
case UNION_TYPE:
if (TYPE_NAME (declspecs)
&& TREE_CODE (TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
{
strcat (buf, "union ");
strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (declspecs)));
strcat (buf, " ");
}
else
strcat (buf, "untagged union ");
break;
case ENUMERAL_TYPE:
if (TYPE_NAME (declspecs)
&& TREE_CODE (TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
{
strcat (buf, "enum ");
strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (declspecs)));
strcat (buf, " ");
}
else
strcat (buf, "untagged enum ");
break;
case VOID_TYPE:
strcat (buf, "void ");
break;
case POINTER_TYPE:
{
tree protocol_list = TYPE_PROTOCOL_LIST (declspecs);
strcat (buf, "id");
if (protocol_list)
{
tree chain = protocol_list;
strcat (buf, " <");
while (chain)
{
strcat (buf,
IDENTIFIER_POINTER
(PROTOCOL_NAME (TREE_VALUE (chain))));
chain = TREE_CHAIN (chain);
if (chain)
strcat (buf, ", ");
}
strcat (buf, ">");
}
}
break;
default:
break;
}
}
}
/* Given a tree node, produce a printable description of it in the given
buffer, overwriting the buffer. */
static char *
gen_declaration (atype_or_adecl, buf)
tree atype_or_adecl;
char *buf;
{
buf[0] = '\0';
gen_declaration_1 (atype_or_adecl, buf);
return buf;
}
/* Given a tree node, append a printable description to the end of the
given buffer. */
static void
gen_declaration_1 (atype_or_adecl, buf)
tree atype_or_adecl;
char *buf;
{
char declbuf[256];
if (TREE_CODE (atype_or_adecl) == TREE_LIST)
{
tree declspecs; /* "identifier_node", "record_type" */
tree declarator; /* "array_ref", "indirect_ref", "call_expr"... */
/* We have a "raw", abstract declarator (typename). */
declarator = TREE_VALUE (atype_or_adecl);
declspecs = TREE_PURPOSE (atype_or_adecl);
gen_declspecs (declspecs, buf, 1);
if (declarator)
{
strcat (buf, " ");
strcat (buf, gen_declarator (declarator, declbuf, ""));
}
}
else
{
tree atype;
tree declspecs; /* "integer_type", "real_type", "record_type"... */
tree declarator; /* "array_type", "function_type", "pointer_type". */
if (TREE_CODE (atype_or_adecl) == FIELD_DECL
|| TREE_CODE (atype_or_adecl) == PARM_DECL
|| TREE_CODE (atype_or_adecl) == FUNCTION_DECL)
atype = TREE_TYPE (atype_or_adecl);
else
/* Assume we have a *_type node. */
atype = atype_or_adecl;
if (is_complex_decl (atype))
{
tree chain;
/* Get the declaration specifier; it is at the end of the list. */
declarator = chain = atype;
do
chain = TREE_TYPE (chain); /* not TREE_CHAIN (chain); */
while (is_complex_decl (chain));
declspecs = chain;
}
else
{
declspecs = atype;
declarator = NULL_TREE;
}
gen_declspecs (declspecs, buf, 0);
if (TREE_CODE (atype_or_adecl) == FIELD_DECL
|| TREE_CODE (atype_or_adecl) == PARM_DECL
|| TREE_CODE (atype_or_adecl) == FUNCTION_DECL)
{
const char *const decl_name =
(DECL_NAME (atype_or_adecl)
? IDENTIFIER_POINTER (DECL_NAME (atype_or_adecl)) : "");
if (declarator)
{
strcat (buf, " ");
strcat (buf, gen_declarator (declarator, declbuf, decl_name));
}
else if (decl_name[0])
{
strcat (buf, " ");
strcat (buf, decl_name);
}
}
else if (declarator)
{
strcat (buf, " ");
strcat (buf, gen_declarator (declarator, declbuf, ""));
}
}
}
#define RAW_TYPESPEC(meth) (TREE_VALUE (TREE_PURPOSE (TREE_TYPE (meth))))
/* Given a method tree, put a printable description into the given
buffer (overwriting) and return a pointer to the buffer. */
static char *
gen_method_decl (method, buf)
tree method;
char *buf;
{
tree chain;
buf[0] = '\0';
if (RAW_TYPESPEC (method) != objc_object_reference)
{
strcat (buf, "(");
gen_declaration_1 (TREE_TYPE (method), buf);
strcat (buf, ")");
}
chain = METHOD_SEL_ARGS (method);
if (chain)
{
/* We have a chain of keyword_decls. */
do
{
if (KEYWORD_KEY_NAME (chain))
strcat (buf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain)));
strcat (buf, ":");
if (RAW_TYPESPEC (chain) != objc_object_reference)
{
strcat (buf, "(");
gen_declaration_1 (TREE_TYPE (chain), buf);
strcat (buf, ")");
}
strcat (buf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain)));
if ((chain = TREE_CHAIN (chain)))
strcat (buf, " ");
}
while (chain);
if (METHOD_ADD_ARGS (method) == objc_ellipsis_node)
strcat (buf, ", ...");
else if (METHOD_ADD_ARGS (method))
{
/* We have a tree list node as generate by get_parm_info. */
chain = TREE_PURPOSE (METHOD_ADD_ARGS (method));
/* Know we have a chain of parm_decls. */
while (chain)
{
strcat (buf, ", ");
gen_declaration_1 (chain, buf);
chain = TREE_CHAIN (chain);
}
}
}
else
/* We have a unary selector. */
strcat (buf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
return buf;
}
/* Debug info. */
/* Dump an @interface declaration of the supplied class CHAIN to the
supplied file FP. Used to implement the -gen-decls option (which
prints out an @interface declaration of all classes compiled in
this run); potentially useful for debugging the compiler too. */
static void
dump_interface (fp, chain)
FILE *fp;
tree chain;
{
/* FIXME: A heap overflow here whenever a method (or ivar)
declaration is so long that it doesn't fit in the buffer. The
code and all the related functions should be rewritten to avoid
using fixed size buffers. */
char *buf = (char *) xmalloc (1024 * 10);
const char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain));
tree ivar_decls = CLASS_RAW_IVARS (chain);
tree nst_methods = CLASS_NST_METHODS (chain);
tree cls_methods = CLASS_CLS_METHODS (chain);
fprintf (fp, "\n@interface %s", my_name);
/* CLASS_SUPER_NAME is used to store the superclass name for
classes, and the category name for categories. */
if (CLASS_SUPER_NAME (chain))
{
const char *name = IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain));
if (TREE_CODE (chain) == CATEGORY_IMPLEMENTATION_TYPE
|| TREE_CODE (chain) == CATEGORY_INTERFACE_TYPE)
{
fprintf (fp, " (%s)\n", name);
}
else
{
fprintf (fp, " : %s\n", name);
}
}
else
fprintf (fp, "\n");
/* FIXME - the following doesn't seem to work at the moment. */
if (ivar_decls)
{
fprintf (fp, "{\n");
do
{
fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls, buf));
ivar_decls = TREE_CHAIN (ivar_decls);
}
while (ivar_decls);
fprintf (fp, "}\n");
}
while (nst_methods)
{
fprintf (fp, "- %s;\n", gen_method_decl (nst_methods, buf));
nst_methods = TREE_CHAIN (nst_methods);
}
while (cls_methods)
{
fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods, buf));
cls_methods = TREE_CHAIN (cls_methods);
}
fprintf (fp, "@end\n");
}
/* Demangle function for Objective-C */
static const char *
objc_demangle (mangled)
const char *mangled;
{
char *demangled, *cp;
if (mangled[0] == '_' &&
(mangled[1] == 'i' || mangled[1] == 'c') &&
mangled[2] == '_')
{
cp = demangled = xmalloc(strlen(mangled) + 2);
if (mangled[1] == 'i')
*cp++ = '-'; /* for instance method */
else
*cp++ = '+'; /* for class method */
*cp++ = '['; /* opening left brace */
strcpy(cp, mangled+3); /* tack on the rest of the mangled name */
while (*cp && *cp == '_')
cp++; /* skip any initial underbars in class name */
cp = strchr(cp, '_'); /* find first non-initial underbar */
if (cp == NULL)
{
free(demangled); /* not mangled name */
return mangled;
}
if (cp[1] == '_') /* easy case: no category name */
{
*cp++ = ' '; /* replace two '_' with one ' ' */
strcpy(cp, mangled + (cp - demangled) + 2);
}
else
{
*cp++ = '('; /* less easy case: category name */
cp = strchr(cp, '_');
if (cp == 0)
{
free(demangled); /* not mangled name */
return mangled;
}
*cp++ = ')';
*cp++ = ' '; /* overwriting 1st char of method name... */
strcpy(cp, mangled + (cp - demangled)); /* get it back */
}
while (*cp && *cp == '_')
cp++; /* skip any initial underbars in method name */
for (; *cp; cp++)
if (*cp == '_')
*cp = ':'; /* replace remaining '_' with ':' */
*cp++ = ']'; /* closing right brace */
*cp++ = 0; /* string terminator */
return demangled;
}
else
return mangled; /* not an objc mangled name */
}
const char *
objc_printable_name (decl, kind)
tree decl;
int kind ATTRIBUTE_UNUSED;
{
return objc_demangle (IDENTIFIER_POINTER (DECL_NAME (decl)));
}
static void
init_objc ()
{
gcc_obstack_init (&util_obstack);
util_firstobj = (char *) obstack_finish (&util_obstack);
errbuf = (char *) xmalloc (BUFSIZE);
hash_init ();
synth_module_prologue ();
}
static void
finish_objc ()
{
struct imp_entry *impent;
tree chain;
/* The internally generated initializers appear to have missing braces.
Don't warn about this. */
int save_warn_missing_braces = warn_missing_braces;
warn_missing_braces = 0;
/* A missing @end may not be detected by the parser. */
if (objc_implementation_context)
{
warning ("`@end' missing in implementation context");
finish_class (objc_implementation_context);
objc_ivar_chain = NULL_TREE;
objc_implementation_context = NULL_TREE;
}
generate_forward_declaration_to_string_table ();
#ifdef OBJC_PROLOGUE
OBJC_PROLOGUE;
#endif
/* Process the static instances here because initialization of objc_symtab
depends on them. */
if (objc_static_instances)
generate_static_references ();
if (imp_list || class_names_chain
|| meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
generate_objc_symtab_decl ();
for (impent = imp_list; impent; impent = impent->next)
{
objc_implementation_context = impent->imp_context;
implementation_template = impent->imp_template;
UOBJC_CLASS_decl = impent->class_decl;
UOBJC_METACLASS_decl = impent->meta_decl;
/* Dump the @interface of each class as we compile it, if the
-gen-decls option is in use. TODO: Dump the classes in the
order they were found, rather than in reverse order as we
are doing now. */
if (flag_gen_declaration)
{
dump_interface (gen_declaration_file, objc_implementation_context);
}
if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
{
/* all of the following reference the string pool... */
generate_ivar_lists ();
generate_dispatch_tables ();
generate_shared_structures ();
}
else
{
generate_dispatch_tables ();
generate_category (objc_implementation_context);
}
}
/* If we are using an array of selectors, we must always
finish up the array decl even if no selectors were used. */
if (! flag_next_runtime || sel_ref_chain)
build_selector_translation_table ();
if (protocol_chain)
generate_protocols ();
if (objc_implementation_context || class_names_chain || objc_static_instances
|| meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
{
/* Arrange for ObjC data structures to be initialized at run time. */
rtx init_sym = build_module_descriptor ();
if (init_sym && targetm.have_ctors_dtors)
(* targetm.asm_out.constructor) (init_sym, DEFAULT_INIT_PRIORITY);
}
/* Dump the class references. This forces the appropriate classes
to be linked into the executable image, preserving unix archive
semantics. This can be removed when we move to a more dynamically
linked environment. */
for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
{
handle_class_ref (chain);
if (TREE_PURPOSE (chain))
generate_classref_translation_entry (chain);
}
for (impent = imp_list; impent; impent = impent->next)
handle_impent (impent);
/* Dump the string table last. */
generate_strings ();
if (warn_selector)
{
int slot;
hash hsh;
/* Run through the selector hash tables and print a warning for any
selector which has multiple methods. */
for (slot = 0; slot < SIZEHASHTABLE; slot++)
for (hsh = cls_method_hash_list[slot]; hsh; hsh = hsh->next)
if (hsh->list)
{
tree meth = hsh->key;
char type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL
? '-' : '+');
attr loop;
warning ("potential selector conflict for method `%s'",
IDENTIFIER_POINTER (METHOD_SEL_NAME (meth)));
warn_with_method ("found", type, meth);
for (loop = hsh->list; loop; loop = loop->next)
warn_with_method ("found", type, loop->value);
}
for (slot = 0; slot < SIZEHASHTABLE; slot++)
for (hsh = nst_method_hash_list[slot]; hsh; hsh = hsh->next)
if (hsh->list)
{
tree meth = hsh->key;
char type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL
? '-' : '+');
attr loop;
warning ("potential selector conflict for method `%s'",
IDENTIFIER_POINTER (METHOD_SEL_NAME (meth)));
warn_with_method ("found", type, meth);
for (loop = hsh->list; loop; loop = loop->next)
warn_with_method ("found", type, loop->value);
}
}
warn_missing_braces = save_warn_missing_braces;
}
/* Subroutines of finish_objc. */
static void
generate_classref_translation_entry (chain)
tree chain;
{
tree expr, name, decl_specs, decl, sc_spec;
tree type;
type = TREE_TYPE (TREE_PURPOSE (chain));
expr = add_objc_string (TREE_VALUE (chain), class_names);
expr = build_c_cast (type, expr); /* cast! */
name = DECL_NAME (TREE_PURPOSE (chain));
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
/* static struct objc_class * _OBJC_CLASS_REFERENCES_n = ...; */
decl_specs = tree_cons (NULL_TREE, type, sc_spec);
/* The decl that is returned from start_decl is the one that we
forward declared in build_class_reference. */
decl = start_decl (name, decl_specs, 1, NULL_TREE);
DECL_CONTEXT (decl) = NULL_TREE;
finish_decl (decl, expr, NULL_TREE);
return;
}
static void
handle_class_ref (chain)
tree chain;
{
const char *name = IDENTIFIER_POINTER (TREE_VALUE (chain));
char *string = (char *) alloca (strlen (name) + 30);
tree decl;
tree exp;
sprintf (string, "%sobjc_class_name_%s",
(flag_next_runtime ? "." : "__"), name);
#ifdef ASM_DECLARE_UNRESOLVED_REFERENCE
if (flag_next_runtime)
{
ASM_DECLARE_UNRESOLVED_REFERENCE (asm_out_file, string);
return;
}
#endif
/* Make a decl for this name, so we can use its address in a tree. */
decl = build_decl (VAR_DECL, get_identifier (string), char_type_node);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
pushdecl (decl);
rest_of_decl_compilation (decl, 0, 0, 0);
/* Make a decl for the address. */
sprintf (string, "%sobjc_class_ref_%s",
(flag_next_runtime ? "." : "__"), name);
exp = build1 (ADDR_EXPR, string_type_node, decl);
decl = build_decl (VAR_DECL, get_identifier (string), string_type_node);
DECL_INITIAL (decl) = exp;
TREE_STATIC (decl) = 1;
TREE_USED (decl) = 1;
pushdecl (decl);
rest_of_decl_compilation (decl, 0, 0, 0);
}
static void
handle_impent (impent)
struct imp_entry *impent;
{
char *string;
objc_implementation_context = impent->imp_context;
implementation_template = impent->imp_template;
if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
{
const char *const class_name =
IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
string = (char *) alloca (strlen (class_name) + 30);
sprintf (string, "%sobjc_class_name_%s",
(flag_next_runtime ? "." : "__"), class_name);
}
else if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
const char *const class_name =
IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
const char *const class_super_name =
IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context));
string = (char *) alloca (strlen (class_name)
+ strlen (class_super_name) + 30);
/* Do the same for categories. Even though no references to
these symbols are generated automatically by the compiler, it
gives you a handle to pull them into an archive by hand. */
sprintf (string, "*%sobjc_category_name_%s_%s",
(flag_next_runtime ? "." : "__"), class_name, class_super_name);
}
else
return;
#ifdef ASM_DECLARE_CLASS_REFERENCE
if (flag_next_runtime)
{
ASM_DECLARE_CLASS_REFERENCE (asm_out_file, string);
return;
}
else
#endif
{
tree decl, init;
init = build_int_2 (0, 0);
TREE_TYPE (init) = c_common_type_for_size (BITS_PER_WORD, 1);
decl = build_decl (VAR_DECL, get_identifier (string), TREE_TYPE (init));
TREE_PUBLIC (decl) = 1;
TREE_READONLY (decl) = 1;
TREE_USED (decl) = 1;
TREE_CONSTANT (decl) = 1;
DECL_CONTEXT (decl) = 0;
DECL_ARTIFICIAL (decl) = 1;
DECL_INITIAL (decl) = init;
assemble_variable (decl, 1, 0, 0);
}
}
/* Look up ID as an instance variable. */
tree
lookup_objc_ivar (id)
tree id;
{
tree decl;
if (objc_method_context && !strcmp (IDENTIFIER_POINTER (id), "super"))
/* We have a message to super. */
return get_super_receiver ();
else if (objc_method_context && (decl = is_ivar (objc_ivar_chain, id)))
{
if (is_private (decl))
return 0;
else
return build_ivar_reference (id);
}
else
return 0;
}
#include "gtype-objc.h"
```
|
A straitjacket is a garment used for restraint.
Straitjacket may also refer to:
Straitjacket (comedy duo), a comedy team from England
Strait Jacket, a novel series by Ichirō Sakaki
Film
Strait-Jacket, a 1964 Columbia Pictures film starring Joan Crawford
Straight-Jacket, a 2004 gay-themed romantic comedy film
Strait Jacket, a 2007 Japanese video series based on the novel series, produced by Feel
Music
Los Straitjackets, an American instrumental band
The Straightjackets, band led by Delbert McClinton
Straitjacket Fits, a New Zealand rock band active from 1986-1994
"Straight Jacket", a 2018 single by Canadian rock band Theory of a Deadman
Other
Straight jacket, a pro wrestling hold
|
The Harry W. Bolens House is a historic house located at 842 West Grand Street in Port Washington, Wisconsin.
Description and history
Built in 1910, the -story house once served as the home of State Senator Harry W. Bolens. The house was added to the National Register of Historic Places on August 25, 1983.
References
Houses in Ozaukee County, Wisconsin
Houses completed in 1910
Houses on the National Register of Historic Places in Wisconsin
National Register of Historic Places in Ozaukee County, Wisconsin
|
```objective-c
//
// This code is licensed under the same terms as WebM:
// Additional IP Rights Grant: path_to_url
// your_sha256_hash-------------
//
// Data-types common to the mux and demux libraries.
//
// Author: Urvang (urvang@google.com)
#ifndef WEBP_WEBP_MUX_TYPES_H_
#define WEBP_WEBP_MUX_TYPES_H_
#include <stdlib.h> // free()
#include <string.h> // memset()
#include "./types.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
// Note: forward declaring enumerations is not allowed in (strict) C and C++,
// the types are left here for reference.
// typedef enum WebPFeatureFlags WebPFeatureFlags;
// typedef enum WebPMuxAnimDispose WebPMuxAnimDispose;
typedef struct WebPData WebPData;
// VP8X Feature Flags.
typedef enum WebPFeatureFlags {
FRAGMENTS_FLAG = 0x00000001,
ANIMATION_FLAG = 0x00000002,
XMP_FLAG = 0x00000004,
EXIF_FLAG = 0x00000008,
ALPHA_FLAG = 0x00000010,
ICCP_FLAG = 0x00000020
} WebPFeatureFlags;
// Dispose method (animation only). Indicates how the area used by the current
// frame is to be treated before rendering the next frame on the canvas.
typedef enum WebPMuxAnimDispose {
WEBP_MUX_DISPOSE_NONE, // Do not dispose.
WEBP_MUX_DISPOSE_BACKGROUND // Dispose to background color.
} WebPMuxAnimDispose;
// Data type used to describe 'raw' data, e.g., chunk data
// (ICC profile, metadata) and WebP compressed image data.
struct WebPData {
const uint8_t* bytes;
size_t size;
};
// Initializes the contents of the 'webp_data' object with default values.
static WEBP_INLINE void WebPDataInit(WebPData* webp_data) {
if (webp_data != NULL) {
memset(webp_data, 0, sizeof(*webp_data));
}
}
// Clears the contents of the 'webp_data' object by calling free(). Does not
// deallocate the object itself.
static WEBP_INLINE void WebPDataClear(WebPData* webp_data) {
if (webp_data != NULL) {
free((void*)webp_data->bytes);
WebPDataInit(webp_data);
}
}
// Allocates necessary storage for 'dst' and copies the contents of 'src'.
// Returns true on success.
static WEBP_INLINE int WebPDataCopy(const WebPData* src, WebPData* dst) {
if (src == NULL || dst == NULL) return 0;
WebPDataInit(dst);
if (src->bytes != NULL && src->size != 0) {
dst->bytes = (uint8_t*)malloc(src->size);
if (dst->bytes == NULL) return 0;
memcpy((void*)dst->bytes, src->bytes, src->size);
dst->size = src->size;
}
return 1;
}
#if defined(__cplusplus) || defined(c_plusplus)
} // extern "C"
#endif
#endif /* WEBP_WEBP_MUX_TYPES_H_ */
```
|
Aemilia crassa is a moth of the family Erebidae. It was described by Francis Walker in 1865. It is found in Colombia.
References
Moths described in 1865
Phaegopterina
Moths of South America
|
```java
/*
* one or more contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright ownership.
*/
package io.camunda.operate.util;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
/** Helper class to rethrow checked exceptions in lambda expressions. */
public final class LambdaExceptionUtil {
/**
* .forEach(rethrowConsumer(name -> System.out.println(Class.forName(name)))); or
* .forEach(rethrowConsumer(ClassNameUtil::println));
*/
public static <T, E extends Exception> Consumer<T> rethrowConsumer(
ConsumerWithExceptions<T, E> consumer) throws E {
return t -> {
try {
consumer.accept(t);
} catch (Exception exception) {
throwAsUnchecked(exception);
}
};
}
public static <T, U, E extends Exception> BiConsumer<T, U> rethrowBiConsumer(
BiConsumerWithExceptions<T, U, E> biConsumer) throws E {
return (t, u) -> {
try {
biConsumer.accept(t, u);
} catch (Exception exception) {
throwAsUnchecked(exception);
}
};
}
/** .map(rethrowFunction(name -> Class.forName(name))) or .map(rethrowFunction(Class::forName)) */
public static <T, R, E extends Exception> Function<T, R> rethrowFunction(
FunctionWithExceptions<T, R, E> function) throws E {
return t -> {
try {
return function.apply(t);
} catch (Exception exception) {
throwAsUnchecked(exception);
return null;
}
};
}
/** rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))), */
public static <T, E extends Exception> Supplier<T> rethrowSupplier(
SupplierWithExceptions<T, E> function) throws E {
return () -> {
try {
return function.get();
} catch (Exception exception) {
throwAsUnchecked(exception);
return null;
}
};
}
/** uncheck(() -> Class.forName("xxx")); */
public static void uncheck(RunnableWithExceptions t) {
try {
t.run();
} catch (Exception exception) {
throwAsUnchecked(exception);
}
}
/** uncheck(() -> Class.forName("xxx")); */
public static <R, E extends Exception> R uncheck(SupplierWithExceptions<R, E> supplier) {
try {
return supplier.get();
} catch (Exception exception) {
throwAsUnchecked(exception);
return null;
}
}
/** uncheck(Class::forName, "xxx"); */
public static <T, R, E extends Exception> R uncheck(
FunctionWithExceptions<T, R, E> function, T t) {
try {
return function.apply(t);
} catch (Exception exception) {
throwAsUnchecked(exception);
return null;
}
}
@SuppressWarnings("unchecked")
private static <E extends Throwable> void throwAsUnchecked(Exception exception) throws E {
throw (E) exception;
}
@FunctionalInterface
public interface ConsumerWithExceptions<T, E extends Exception> {
void accept(T t) throws E;
}
@FunctionalInterface
public interface BiConsumerWithExceptions<T, U, E extends Exception> {
void accept(T t, U u) throws E;
}
@FunctionalInterface
public interface FunctionWithExceptions<T, R, E extends Exception> {
R apply(T t) throws E;
}
@FunctionalInterface
public interface SupplierWithExceptions<T, E extends Exception> {
T get() throws E;
}
@FunctionalInterface
public interface RunnableWithExceptions<E extends Exception> {
void run() throws E;
}
}
```
|
```java
/**
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package com.twitter.distributedlog.service.balancer;
public class LimitedStreamChooser implements StreamChooser {
public static LimitedStreamChooser of(StreamChooser underlying, int limit) {
return new LimitedStreamChooser(underlying, limit);
}
final StreamChooser underlying;
int limit;
LimitedStreamChooser(StreamChooser underlying, int limit) {
this.underlying = underlying;
this.limit = limit;
}
@Override
public synchronized String choose() {
if (limit <= 0) {
return null;
}
String s = underlying.choose();
if (s == null) {
limit = 0;
return null;
}
--limit;
return s;
}
}
```
|
```xml
///
///
///
/// path_to_url
///
/// Unless required by applicable law or agreed to in writing, software
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
///
import { Component, Input, OnInit, TemplateRef, ViewChild, ViewEncapsulation } from '@angular/core';
import { WidgetContext } from '@home/models/widget-component.models';
import { WidgetComponent } from '@home/components/widget/widget.component';
import { TranslateService } from '@ngx-translate/core';
import { TbPieChart } from '@home/components/widget/lib/chart/pie-chart';
import {
LatestChartComponent,
LatestChartComponentCallbacks
} from '@home/components/widget/lib/chart/latest-chart.component';
import {
pieChartWidgetDefaultSettings,
pieChartWidgetPieChartSettings,
PieChartWidgetSettings
} from '@home/components/widget/lib/chart/pie-chart-widget.models';
@Component({
selector: 'tb-pie-chart-widget',
templateUrl: './latest-chart-widget.component.html',
styleUrls: [],
encapsulation: ViewEncapsulation.None
})
export class PieChartWidgetComponent implements OnInit {
@ViewChild('latestChart')
latestChart: LatestChartComponent;
@Input()
ctx: WidgetContext;
@Input()
widgetTitlePanel: TemplateRef<any>;
settings: PieChartWidgetSettings;
callbacks: LatestChartComponentCallbacks;
constructor(private widgetComponent: WidgetComponent,
private translate: TranslateService) {
}
ngOnInit(): void {
this.ctx.$scope.pieChartWidget = this;
this.settings = {...pieChartWidgetDefaultSettings, ...this.ctx.settings};
this.callbacks = {
createChart: (chartShape, renderer) => {
const settings = pieChartWidgetPieChartSettings(this.settings);
return new TbPieChart(this.ctx, settings, chartShape.nativeElement, renderer, this.translate, true);
},
onItemClick: ($event: Event, item) => {
const descriptors = this.ctx.actionsApi.getActionDescriptors('sliceClick');
if ($event && descriptors.length) {
$event.stopPropagation();
const datasource = item.datasource;
const entityId = datasource ? datasource.entity?.id : null;
const entityName = datasource ? datasource.entityName : null;
const entityLabel = datasource ? datasource.entityLabel : null;
this.ctx.actionsApi.handleWidgetAction($event, descriptors[0], entityId, entityName, item, entityLabel);
}
}
};
}
public onInit() {
this.latestChart?.onInit();
}
public onDataUpdated() {
this.latestChart?.onDataUpdated();
}
}
```
|
Air West is an airline based in Khartoum, Sudan. It operates domestic passenger services and international cargo charters. Its main base is Khartoum International Airport, with a hub at Sharjah International Airport.
This airline has no connection to Hughes Airwest which previously operated in the U.S. as Air West.
The airline is on the List of air carriers banned in the European Union.
History
The airline was established in April 1992 and started operations in October 1992.
Incidents and accidents
On January 24, 2007, Air West Flight 612, a Boeing 737 with 95 passengers and 8 crew on board, was hijacked and diverted to the Chadian capital of N'Djamena. The plane, destined for the town of El Fasher, took off from Khartoum at 8:30 AM. Air traffic control had evidence of only one hijacker aboard the plane. The 24-year-old hijacker, Mahamat Abdelatif Mahamat, was armed with a pistol and several knives. He demanded that the airplane be flown to Britain. When he realized that there was not enough fuel to go to Britain he asked to be flown to Bangui or N'Djamena. The aircraft landed safely in N'Djamena and all passengers were released. The hijacker requested guarantees for his safety from the French embassy and requested political asylum in the United Kingdom. The hijacker's demands were not heeded; he was arrested following twenty minutes of negotiations on the ground.
Destinations
Air West does public services to Sudan, Egypt and Saudi Arabia.
Fleet
The Air West fleet consists of the following aircraft (as of 4 April 2018):
1 Airbus A300-600 (265)
2 Antonov An-24 (44)
1 Antonov An-28 (18)
1 Boeing 737-300QC (148)
2 Fokker 50 (50)
Total:7
References
External links
Air West Fleet
Airlines of Sudan
Airlines established in 1992
1992 establishments in Sudan
Companies based in Khartoum
|
```ruby
class CreateRecommendedArticlesLists < ActiveRecord::Migration[7.0]
def change
create_table :recommended_articles_lists do |t|
t.string :name
t.integer :article_ids, array: true, default: []
t.integer :placement_area, default: 0
t.datetime :expires_at
t.references :user, null: false, foreign_key: true
t.timestamps
end
end
end
#add_column :display_ads, :exclude_article_ids, :integer, array: true, default: []
```
|
```ruby
# frozen_string_literal: false
require_relative 'helper'
module DTrace
class TestFunctionEntry < TestCase
def test_function_entry
probe = <<-eoprobe
ruby$target:::method-entry
/arg0 && arg1 && arg2/
{
printf("%s %s %s %d\\n", copyinstr(arg0), copyinstr(arg1), copyinstr(arg2), arg3);
}
eoprobe
trap_probe(probe, ruby_program) { |d_file, rb_file, probes|
foo_calls = probes.map { |line| line.split }.find_all { |row|
row.first == 'Foo' && row[1] == 'foo'
}
assert_equal 10, foo_calls.length, probes
line = '3'
foo_calls.each { |f| assert_equal line, f[3] }
foo_calls.each { |f| assert_equal rb_file, f[2] }
}
end
def test_function_return
probe = <<-eoprobe
ruby$target:::method-return
/arg0 && arg1 && arg2/
{
printf("%s %s %s %d\\n", copyinstr(arg0), copyinstr(arg1), copyinstr(arg2), arg3);
}
eoprobe
trap_probe(probe, ruby_program) { |d_file, rb_file, probes|
foo_calls = probes.map { |line| line.split }.find_all { |row|
row.first == 'Foo' && row[1] == 'foo'
}
assert_equal 10, foo_calls.length, probes.inspect
line = '3'
foo_calls.each { |f| assert_equal line, f[3] }
foo_calls.each { |f| assert_equal rb_file, f[2] }
}
end
def test_return_from_raise
program = <<-eoruby
class Foo
def bar; raise; end
def baz
bar
rescue
end
end
Foo.new.baz
eoruby
probe = <<-eoprobe
ruby$target:::method-return
/arg0 && arg1 && arg2/
{
printf("%s %s %s %d\\n", copyinstr(arg0), copyinstr(arg1), copyinstr(arg2), arg3);
}
eoprobe
trap_probe(probe, program) { |d_file, rb_file, probes|
foo_calls = probes.map { |line| line.split }.find_all { |row|
row.first == 'Foo' && row[1] == 'bar'
}
assert foo_calls.any?
}
end
private
def ruby_program
<<-eoruby
TracePoint.new{}.__enable(nil, nil, Thread.current)
class Foo
def foo; end
end
x = Foo.new
10.times { x.foo }
eoruby
end
end
end if defined?(DTrace::TestCase)
```
|
```text
Alternative Names
0
PARAM.SFO
/*
Assassin's Creed Ezio Trilogy
*/
#
Infinite HP
0
xtatu
0 00613E7C 60000000
#
Infinite Money
0
xtatu
0 00A5DFA4 60000000
#
```
|
The Church of Jesus Christ of Latter-day Saints in Kentucky refers to the Church of Jesus Christ of Latter-day Saints (LDS Church) and its members in Kentucky. The first small branch was established in 1834. It has since grown to 37,830 members in 83 congregations.
Official church membership as a percentage of general population was 0.77% in 2014. According to the 2014 Pew Forum on Religion & Public Life survey, less than 1% of Kentuckians self-identify themselves most closely with The Church of Jesus Christ of Latter-day Saints. The LDS Church is the 8th largest denomination in Kentucky.
Stakes are located in Crestwood, Elizabethtown, Hopkinsville, Lexington (2), Louisville, and Paducah.
History
In 1835, two missionaries baptized 22 people and the first group of Kentucky Saints left for Missouri in September 1836.
In 2011, Lexington native Rob Hymas, became an area seventy and oversaw 10 stake presidents in Kentucky and Tennessee.
Stakes
As of February 2023, there were 8 stakes with their stake center located in Kentucky.
Stakes with congregations in Kentucky are as follows:
Mission
The East Central States Mission was created on December 9, 1928 which took in portions of what was previously Southern States Mission and Eastern States Mission. Kentucky itself was previously in the Southern States Mission. On June 10, 1970, it was renamed the Kentucky-Tennessee Mission. On June 20, 1974, it was renamed the Kentucky Louisville Mission.
Temples
The Louisville Kentucky Temple was dedicated on March 19, 2000 by President Thomas S. Monson.
See also
The Church of Jesus Christ of Latter-day Saints membership statistics (United States)
References
External links
Newsroom (Kentucky)
ComeUntoChrist.org Latter-day Saints Visitor site
The Church of Jesus Christ of Latter-day Saints Official site
Kentucky
|
```javascript
function *g() { var z = function(yield) {} }
```
|
```c++
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/bailout-reason.h"
#include "src/base/logging.h"
namespace v8 {
namespace internal {
const char* GetBailoutReason(BailoutReason reason) {
DCHECK(reason < kLastErrorMessage);
#define ERROR_MESSAGES_TEXTS(C, T) T,
static const char* error_messages_[] = {
ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)};
#undef ERROR_MESSAGES_TEXTS
return error_messages_[reason];
}
} // namespace internal
} // namespace v8
```
|
```java
/* ===========================================================
* JFreeChart : a free chart library for the Java(tm) platform
* ===========================================================
*
*
* Project Info: path_to_url
*
* This library is free software; you can redistribute it and/or modify it
* (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 Lesser General Public
*
* You should have received a copy of the GNU Lesser General Public
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* [Oracle and Java are registered trademarks of Oracle and/or its affiliates.
* Other names may be trademarks of their respective owners.]
*
* ---------------------------------
* DefaultPolarItemRendererTest.java
* ---------------------------------
*
* Original Author: David Gilbert;
* Contributor(s): -;
*
*/
package org.jfree.chart.renderer;
import org.jfree.chart.TestUtils;
import org.jfree.chart.internal.CloneUtils;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* Tests for the {@link DefaultPolarItemRenderer} class.
*/
public class DefaultPolarItemRendererTest {
/**
* Check that the equals() method distinguishes all fields.
*/
@Test
public void testEquals() {
DefaultPolarItemRenderer r1 = new DefaultPolarItemRenderer();
DefaultPolarItemRenderer r2 = new DefaultPolarItemRenderer();
assertEquals(r1, r2);
r1.setSeriesFilled(1, true);
assertNotEquals(r1, r2);
r2.setSeriesFilled(1, true);
assertEquals(r1, r2);
}
/**
* Two objects that are equal are required to return the same hashCode.
*/
@Test
public void testHashcode() {
DefaultPolarItemRenderer r1 = new DefaultPolarItemRenderer();
DefaultPolarItemRenderer r2 = new DefaultPolarItemRenderer();
assertEquals(r1, r2);
int h1 = r1.hashCode();
int h2 = r2.hashCode();
assertEquals(h1, h2);
}
/**
* Confirm that cloning works.
*/
@Test
public void testCloning() throws CloneNotSupportedException {
DefaultPolarItemRenderer r1 = new DefaultPolarItemRenderer();
DefaultPolarItemRenderer r2 = CloneUtils.clone(r1);
assertNotSame(r1, r2);
assertSame(r1.getClass(), r2.getClass());
assertEquals(r1, r2);
r1.setSeriesFilled(1, true);
assertNotEquals(r1, r2);
r2.setSeriesFilled(1, true);
assertEquals(r1, r2);
}
/**
* Serialize an instance, restore it, and check for equality.
*/
@Test
public void testSerialization() {
DefaultPolarItemRenderer r1 = new DefaultPolarItemRenderer();
DefaultPolarItemRenderer r2 = TestUtils.serialised(r1);
assertEquals(r1, r2);
}
}
```
|
```yaml
#
#
---
################################################################################
#
# Orderer Configuration
#
# - This controls the type and configuration of the orderer.
#
################################################################################
General:
# Listen address: The IP on which to bind to listen.
ListenAddress: 127.0.0.1
# Listen port: The port on which to bind to listen.
ListenPort: 7050
# TLS: TLS settings for the GRPC server.
TLS:
Enabled: false
# PrivateKey governs the file location of the private key of the TLS certificate.
PrivateKey: crypto/ordererOrganizations/example.com/orderers/127.0.0.1.example.com/tls/server.key
# Certificate governs the file location of the server TLS certificate.
Certificate: crypto/ordererOrganizations/example.com/orderers/127.0.0.1.example.com/tls/server.crt
RootCAs:
- crypto/ordererOrganizations/example.com/orderers/127.0.0.1.example.com/tls/ca.crt
ClientAuthRequired: false
ClientRootCAs:
# Keepalive settings for the GRPC server.
Keepalive:
# ServerMinInterval is the minimum permitted time between client pings.
# If clients send pings more frequently, the server will
# disconnect them.
ServerMinInterval: 60s
# ServerInterval is the time between pings to clients.
ServerInterval: 7200s
# ServerTimeout is the duration the server waits for a response from
# a client before closing the connection.
ServerTimeout: 20s
# Cluster settings for ordering service nodes that communicate with other ordering service nodes
# such as Raft based ordering service.
Cluster:
# SendBufferSize is the maximum number of messages in the egress buffer.
# Consensus messages are dropped if the buffer is full, and transaction
# messages are waiting for space to be freed.
SendBufferSize: 100
# ClientCertificate governs the file location of the client TLS certificate
# used to establish mutual TLS connections with other ordering service nodes.
ClientCertificate:
# ClientPrivateKey governs the file location of the private key of the client TLS certificate.
ClientPrivateKey:
# The below 4 properties should be either set together, or be unset together.
# If they are set, then the orderer node uses a separate listener for intra-cluster
# communication. If they are unset, then the general orderer listener is used.
# This is useful if you want to use a different TLS server certificates on the
# client-facing and the intra-cluster listeners.
# ListenPort defines the port on which the cluster listens to connections.
ListenPort:
# ListenAddress defines the IP on which to listen to intra-cluster communication.
ListenAddress:
# ServerCertificate defines the file location of the server TLS certificate used for intra-cluster
# communication.
ServerCertificate:
# ServerPrivateKey defines the file location of the private key of the TLS certificate.
ServerPrivateKey:
# Genesis method: The method by which the genesis block for the orderer
# system channel is specified. The option can be one of:
# "file" - (deprecated) path to a file containing the genesis block or config block of system channel
# "none" - allows an orderer to start without a system channel configuration
GenesisMethod: none
# The file containing the genesis block to use when initializing the orderer system channel
# (deprecated)
GenesisFile: genesisblock
# LocalMSPDir is where to find the private crypto material needed by the
# orderer. It is set relative here as a default for dev environments but
# should be changed to the real location in production.
LocalMSPDir: crypto/ordererOrganizations/example.com/orderers/127.0.0.1.example.com/msp
# LocalMSPID is the identity to register the local MSP material with the MSP
# manager. IMPORTANT: The local MSP ID of an orderer needs to match the MSP
# ID of one of the organizations defined in the orderer system channel's
# /Channel/Orderer configuration. The sample organization defined in the
# sample configuration provided has an MSP ID of "SampleOrg".
LocalMSPID: SampleOrg
# Enable an HTTP service for Go "pprof" profiling as documented at:
# path_to_url
Profile:
Enabled: false
Address: 0.0.0.0:6060
# BCCSP configures the blockchain crypto service providers.
BCCSP:
# Default specifies the preferred blockchain crypto service provider
# to use. If the preferred provider is not available, the software
# based provider ("SW") will be used.
# Valid providers are:
# - SW: a software based crypto provider
# - PKCS11: a CA hardware security module crypto provider.
Default: SW
# SW configures the software based blockchain crypto provider.
SW:
# TODO: The default Hash and Security level needs refactoring to be
# fully configurable. Changing these defaults requires coordination
# SHA2 is hardcoded in several places, not only BCCSP
Hash: SHA2
Security: 256
# Location of key store. If this is unset, a location will be
# chosen using: 'LocalMSPDir'/keystore
FileKeyStore:
KeyStore:
# Authentication contains configuration parameters related to authenticating
# client messages
Authentication:
# the acceptable difference between the current server time and the
# client's time as specified in a client request message
TimeWindow: 15m
################################################################################
#
# SECTION: File Ledger
#
# - This section applies to the configuration of the file ledger.
#
################################################################################
FileLedger:
# Location: The directory to store the blocks in.
Location: /var/hyperledger/production/orderer
################################################################################
#
# Debug Configuration
#
# - This controls the debugging options for the orderer
#
################################################################################
Debug:
# BroadcastTraceDir when set will cause each request to the Broadcast service
# for this orderer to be written to a file in this directory
BroadcastTraceDir:
# DeliverTraceDir when set will cause each request to the Deliver service
# for this orderer to be written to a file in this directory
DeliverTraceDir:
################################################################################
#
# Operations Configuration
#
# - This configures the operations server endpoint for the orderer
#
################################################################################
Operations:
# host and port for the operations server
ListenAddress: 127.0.0.1:8443
# TLS configuration for the operations endpoint
TLS:
# TLS enabled
Enabled: false
# Certificate is the location of the PEM encoded TLS certificate
Certificate:
# PrivateKey points to the location of the PEM-encoded key
PrivateKey:
# Most operations service endpoints require client authentication when TLS
# is enabled. ClientAuthRequired requires client certificate authentication
# at the TLS layer to access all resources.
ClientAuthRequired: false
# Paths to PEM encoded ca certificates to trust for client authentication
ClientRootCAs: []
################################################################################
#
# Metrics Configuration
#
# - This configures metrics collection for the orderer
#
################################################################################
Metrics:
# The metrics provider is one of statsd, prometheus, or disabled
Provider: disabled
# The statsd configuration
Statsd:
# network type: tcp or udp
Network: udp
# the statsd server address
Address: 127.0.0.1:8125
# The interval at which locally cached counters and gauges are pushed
# to statsd; timings are pushed immediately
WriteInterval: 30s
# The prefix is prepended to all emitted statsd metrics
Prefix:
################################################################################
#
# Channel participation API Configuration
#
# - This provides the channel participation API configuration for the orderer.
# - Channel participation uses the same ListenAddress and TLS settings of the
# Operations service.
#
################################################################################
ChannelParticipation:
# Channel participation API is enabled. Deprecated: must be set to true.
Enabled: true
# The maximum size of the request body when joining a channel.
MaxRequestBodySize: 1 MB
################################################################################
#
# Consensus Configuration
#
# - This section contains config options for a consensus plugin. It is opaque
# to orderer, and completely up to consensus implementation to make use of.
#
################################################################################
Consensus:
# The allowed key-value pairs here depend on consensus plugin. For etcd/raft,
# we use following options:
# WALDir specifies the location at which Write Ahead Logs for etcd/raft are
# stored. Each channel will have its own subdir named after channel ID.
WALDir: /var/hyperledger/production/orderer/etcdraft/wal
# SnapDir specifies the location at which snapshots for etcd/raft are
# stored. Each channel will have its own subdir named after channel ID.
SnapDir: /var/hyperledger/production/orderer/etcdraft/snapshot
```
|
```php
<?php
/*
* This file is part of SwiftMailer.
* (c) 2004-2009 Chris Corbyn
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
/**
* An attachment, in a multipart message.
*
* @author Chris Corbyn
*/
class Swift_Mime_Attachment extends Swift_Mime_SimpleMimeEntity
{
/** Recognized MIME types */
private $_mimeTypes = array();
/**
* Create a new Attachment with $headers, $encoder and $cache.
*
* @param Swift_Mime_HeaderSet $headers
* @param Swift_Mime_ContentEncoder $encoder
* @param Swift_KeyCache $cache
* @param Swift_Mime_Grammar $grammar
* @param array $mimeTypes optional
*/
public function __construct(Swift_Mime_HeaderSet $headers, Swift_Mime_ContentEncoder $encoder, Swift_KeyCache $cache, Swift_Mime_Grammar $grammar, $mimeTypes = array())
{
parent::__construct($headers, $encoder, $cache, $grammar);
$this->setDisposition('attachment');
$this->setContentType('application/octet-stream');
$this->_mimeTypes = $mimeTypes;
}
/**
* Get the nesting level used for this attachment.
*
* Always returns {@link LEVEL_MIXED}.
*
* @return int
*/
public function getNestingLevel()
{
return self::LEVEL_MIXED;
}
/**
* Get the Content-Disposition of this attachment.
*
* By default attachments have a disposition of "attachment".
*
* @return string
*/
public function getDisposition()
{
return $this->_getHeaderFieldModel('Content-Disposition');
}
/**
* Set the Content-Disposition of this attachment.
*
* @param string $disposition
*
* @return Swift_Mime_Attachment
*/
public function setDisposition($disposition)
{
if (!$this->_setHeaderFieldModel('Content-Disposition', $disposition)) {
$this->getHeaders()->addParameterizedHeader(
'Content-Disposition', $disposition
);
}
return $this;
}
/**
* Get the filename of this attachment when downloaded.
*
* @return string
*/
public function getFilename()
{
return $this->_getHeaderParameter('Content-Disposition', 'filename');
}
/**
* Set the filename of this attachment.
*
* @param string $filename
*
* @return Swift_Mime_Attachment
*/
public function setFilename($filename)
{
$this->_setHeaderParameter('Content-Disposition', 'filename', $filename);
$this->_setHeaderParameter('Content-Type', 'name', $filename);
return $this;
}
/**
* Get the file size of this attachment.
*
* @return int
*/
public function getSize()
{
return $this->_getHeaderParameter('Content-Disposition', 'size');
}
/**
* Set the file size of this attachment.
*
* @param int $size
*
* @return Swift_Mime_Attachment
*/
public function setSize($size)
{
$this->_setHeaderParameter('Content-Disposition', 'size', $size);
return $this;
}
/**
* Set the file that this attachment is for.
*
* @param Swift_FileStream $file
* @param string $contentType optional
*
* @return Swift_Mime_Attachment
*/
public function setFile(Swift_FileStream $file, $contentType = null)
{
$this->setFilename(basename($file->getPath()));
$this->setBody($file, $contentType);
if (!isset($contentType)) {
$extension = strtolower(substr(
$file->getPath(), strrpos($file->getPath(), '.') + 1
));
if (array_key_exists($extension, $this->_mimeTypes)) {
$this->setContentType($this->_mimeTypes[$extension]);
}
}
return $this;
}
}
```
|
Gerhard Rochus "Gerd" Dudek (28 September 1938 – 3 November 2022) was a German jazz tenor and soprano saxophonist, clarinetist and flautist.
Dudek studied clarinet privately and attended music school in the 1950s, before joining a big band led by his brother Ossi until 1958. During the early 1960s, Dudek played in the Berliner Jazz Quintet, in Karl Blume's group and in Kurt Edelhagen's orchestra until 1965. He then became interested in free music and joined Manfred Schoof's quintet. Dudek took part in the first sessions of The Globe Unity Orchestra in 1966, and played with them at various times into the 1980s. He also worked with many other European free musicians and composers, including Alexander von Schlippenbach, Loek Dikker and The Waterland Ensemble And European Jazz Quintet.
Dudek was best known for his work with Manfred Schoof, Wolfgang Dauner, Lala Kovacev, the Globe Unity Orchestra, Berlin Contemporary Jazz Orchestra, Albert Mangelsdorff, Don Cherry and George Russell.
Dudek died on 3 November 2022, at the age of 84.
Discography
As leader
'Smatter (Psi, 2002)
Day and Night (Psi, 2012)
With You (JazzJazz, 2023)
As co-leader
Flying to the Sky (Trio, 1971) with Takehiro Honda
Morning Rise (Ego, 1977) with Alan Skidmore, Adelhard Roidinger, and Branislav Kovačev
Open (FMP, 1979) with Buschi Niebergall and Edward Vesala
After All (Konnex, 1991) with Ali Haurand and Rob van den Broeck
Pulque (Konnex, 1993) with Ali Haurand and Rob van den Broeck
Crossing Level (Konnex, 1997) with Rob van den Broeck, Ali Haurand and Tony Levin
Schinderkarren Mit Büffet (Konnex, 2002) with Paul Eßer, Ali Haurand and Jiri Stivin
The Art of Duo (Laika, 2005) with Michael Mikolaschek
Lyrik & Jazz Cascaden (Konnex, 2006) with Ingeborg Drews and Ali Haurand
Sound Solutions (self-released, 2013) with Max Bolleman and Rob van den Broeck
Nunc! (Nemu, 2014) with Misha Mengelberg, Dirk Bell, Ryan Carniaux, Joscha Oetz, and Nils Tegen
Two of Us Are One (Shaa, 2015) with Stefan Heidtmann
Live (self-released, 2021) with the Hans Koller Trio
As sideman
With the Berlin Contemporary Jazz Orchestra
Berlin Contemporary Jazz Orchestra (ECM, 1990)
Live in Japan '96 (DIW, 1997)
With Wolfgang Dauner
Free Action (SABA, 1967)
Requiem / Psalmus Spei (MPS, 1969)
With the European Jazz Ensemble
20th Anniversary Tour (Konnex, 1997)
25th Anniversary Tour (Konnex, 2002)
30 Years on the Road (Konnex, 2006) DVD
35th Anniversary Tour (Konnex, 2011)
With the European Jazz Quintet
Live At Moers Festival (Moers, 1977)
European Jazz Quintet (Ego, 1978)
European Jazz Quintet III (Fusion, 1982)
With the German All Stars
Live at the Domicile (MPS, 1971)
Out of Each/German All Stars in Japan (Columbia, 1971)
With the Globe Unity Orchestra
Live in Wuppertal (FMP, 1973)
Evidence, Vol 1 (FMP, 1976)
Into the Valley, Vol 2 (FMP, 1976)
Pearls (FMP, 1977)
Jahrmarkt / Local Fair (PTR/JWD, 1977)
Improvisations (Japo, 1978)
Compositions (Japo, 1979)
Hamburg '74 (FMP, 1979)
Intergalactic Blow (Japo, 1983)
Rumbling (FMP, 1991)
20th Anniversary (FMP, 1993)
Globe Unity 67 & 70 (Atavistic, 2001)
Globe Unity 40 Years (Intakt, 2008)
Live In Berlin (Jazzwerkstatt, 2010)
Baden-Baden '75 (FMP, 2011)
...Und Jetzt Die Sportschau (Trost, 2013)
Globe Unity 50 Years (Intakt, 2018)
With Alexander von Schlippenbach
Globe Unity (SABA, 1967)
With Manfred Schoof
Voices (CBS, 1966)
Manfred Schoof Sextet (Wergo, 1967)
European Echoes (FMP, 1969)
The Early Quintet (FMP, 1978)
Reflections (Mood, 1984)
With others
With Peter Brötzmann: Fuck de Boere (Atavistic, 2001)
With Jack Bruce: Somethin Els (CMP, 1993)
With Can: The Lost Tapes (Spoon, 2012)
With Gabi Delgado: Mistress (Virgin, 1983)
With Drum Circus: Magic Theatre (Garden Of Delights, 2003)
With Kurt Edelhagen and His Orchestra: The Unreleased WDR Jazz Recordings 1957 - 1974 (Jazzline, 2021)
With Kurt Edelhagen and Wolfgang Sauer: Kurt Edelhagen - Wolfgang Sauer (Amiga, 1965)
With European Jazz Trio: European Jazz Trio (Konnex, 2013)
With Four for Jazz: Sunday Child (Spiegelei , 1972)
With Peter Giger: A Drum Is a Woman - The Best of Peter Giger (Intuition, 2006)
With Guru Guru: Mani und seine Freunde (Atlantic, 1975)
With Ján Hajnal: Dedication (Hevhetia, 2020)
With Hellmut Hattler: Bassball (Harvest, 1977)
With Ali Haurand: Ballads (Konnex, 2005)
With Horns Ensemble (Günter Christmann, Albert Mangelsdorff, Paul Rutherford, Manfred Schoof, Kenny Wheeler): Horns (FMP, 1979)
With Knut Kiesewetter: Stop! Watch! and Listen! (MPS, 1970)
With Joachim Kühn: This Way Out (MPS, 1973)
With Lerryn: Goya Malt Karl IV (Columbia, 1978)
With Albert Mangelsdorff: Birds of Underground (MPS, 1973)
With Krzysztof Penderecki and Don Cherry: Actions (Philips, 1971)
With Oscar Pettiford: We Get the Message (Sonorama, 2015)
With Dieter Reith: Reith On! (Motor, 1999)
With Irmin Schmidt: Villa Wunderbar (Spoon, 2013)
With Wolfgang Schmidtke: Monk! (Jazzwerkstatt, 2018)
With Tobias Sudhoff: Polarlichter (Laika, 2004)
With Third Eye: Connexion (Ring, 1977)
With various artists: Gittin' to Know Y'All (MPS, 1970)
With various artists: Free Zone Appleby 2005 (Psi, 2006)
With the Wunsch / Strauch Sextet: Joana's Waltz (Jazz'N'Arts, 2005)
References
External links
Dudeks FMP releases
1938 births
2022 deaths
German jazz flautists
German jazz saxophonists
Male saxophonists
German jazz clarinetists
21st-century saxophonists
21st-century clarinetists
21st-century German male musicians
German male jazz musicians
Berlin Contemporary Jazz Orchestra members
Globe Unity Orchestra members
European Jazz Ensemble members
21st-century flautists
Psi Records artists
|
Alice Anderson (born 1966) is an American poet. She is particularly known for her collection, Human Nature.
Biography
Alice Anderson was born May 20, 1966, in Tulsa, Oklahoma. She spent her childhood in California and Mississippi. Anderson's work deals with issues that have impacted her life: family violence, intimate partner violence, and traumatic brain injury.
Anderson was living in Ocean Springs, Mississippi when Hurricane Katrina hit.
Anderson took a classes at California State University, Sacramento, receiving a BA in English. As an undergrad Anderson worked with the poet Dennis Schmitz who encouraged her to go to graduate school.
She received an MFA in Poetry from Sarah Lawrence College.
Anderson's, multi-genre, oeuvre explores using language to reveal universal illuminations that arise from suffering.
Awards
1994 Elmer Holmes Bobst Award for Emerging Writers
1994 Sarah Lawrence Poetry Prize
Works
Some Bright Morning, I'll Fly Away: A Memoir (St. Martin's Press, 2017)
The Watermark (Eyewear Publishing, 2016)
Human Nature (NYU Press, 1994)
References
External links
The Reading Life With Alice Anderson on New Orleans Public Radio
21st-century American poets
20th-century American poets
21st-century American women writers
20th-century American women writers
American women poets
Writers from Tulsa, Oklahoma
Poets from Oklahoma
1966 births
Living people
Sarah Lawrence College alumni
California State University, Sacramento alumni
|
Events in the year 1868 in Uruguay.
Incumbents
Interim Governor: Venancio Flores until February 15. Acting president from the Senate: Pedro Varela until 1 March. President: Lorenzo Batlle since 1 March.
Events
Establishment of Cementerio del Cerro, Montevideo.
23 January - the first Uruguayan Civil Code is passed, approved by Law No. 917 of 23 January 1868, and was scheduled to come into force in 19 April of the same year.
4 February - the first Uruguayan Mining Code is passed, approved by Law No. 920 of 4 February 1868.
30 April - the parliament gave legal approval to the regulations with purported force of law issued by the Interim Governorship led by general Venancio Flores, from 20 February 1865 to 15 February 1868.
20 July - due to the death of Venancio Flores, the General Assembly declared a day of national mourning his day of death in 19 February 1869 and that day yearly. This would be held until 1914, when all the holidays of mournings were repealed.
Deaths
February 19
Bernardo Berro (64), Uruguayan politician and writer, president of Uruguay in the period 1860-1864; assassinated (b. 1803).
Venancio Flores (59), Uruguayan politician and military figure, president of Uruguay in the period 1853-1855 and interim governor in the period 1865-1868; assassinated (b. 1808).
References
|
Ernst Karl (sometimes also Carl) Erdmann Heine (January 10, 1819 – August 25, 1888) was a lawyer in Leipzig and a major entrepreneur and industrial pioneer who shaped the face of the western suburbs of Leipzig.
Life
Karl Heine was born in Leipzig, to the owner of Neuscherbitz Estate, Johann Carl Friedrich Heine, and his wife Christiana Dorothea, née Reichel (1781–1857). He attended the Thomasschule zu Leipzig, a public boarding school in Leipzig. Later he studied law at the University of Leipzig - he was member of the Corps Saxonia Leipzig fraternity. He received a doctorate on the economic use of waterways and shores according to Saxon state law. Later, he established himself as a barrister in Leipzig .
After the death of his grandfather E.T. Reichel (1748–1832), Karl Heine bought the shares of Reichel's Garden from another heir, took these pieces of land and from the medial of the 19th century on, he gradually built what is today the inner western suburb of Leipzig.
In 1854, Heine also expanded his estate in the Gemeinde Plagwitz district of Leipzig; in 1856, he began the construction of the first section of a navigable canal connecting the rivers White Elster and Saale, which today bears his name (Karl Heine Canal). The excavation of the canal reclaimed which was later to become the western suburb of Leipzig. To institute his plans for construction and industrialization, Heine established an "economy" in Plagwitz.
When the western suburb was connected to Gemeinde Plagwitz, Heine constructed the Plagwitzer Straße (today named Käthe-Kollwitz-Straße), a street to the south of the old highway from Leipzig to Lindenau, which ran parallel to the new street. Against the opposition of the Leipzig council, he also built the Plagwitz bridge, which connected to the Leipziger Straße in Plagwitz (today: Karl-Heine-Straße).
Karl Heine was a member of the Saxon Diet from 1870 to his death. He was also a representative in the Leipzig city council.
In 1874, he moved into his newly built villa in Neuschleußig (Karl-Heine-Villa, Könneritzstraße 1), where he resided until his death.
In 1876, a construction scheme was approved which encompassed merging Karl Heine's meadows and fields in the northern part of Schleußig (Neuschleußig) with Bernhard Hüffer's (1824–1904) estate and extensive undeveloped forest land. These areas would be designated as new residential areas.
On May 24, 1888, Heine founded the Westend-Baugesellschaft, a construction company, to continue his work in developing the Leipzig economy after his death.
Since 1854, Karl Heine had also been a member of the Leipzig masonic lodge Apollo. He died on August 25, 1888, aged 69, in Leipzig.
Honours
In 1897, the city of Leipzig honoured Karl Heine with a monument. The monument was melted down in the Second World War but was renewed in 2001. Many streets and one plaza are named after him. (Erdmannstraße, 1891; Karl-Heine-Strasse, 1904; Karl-Heine-Platz, et al.)
In 2003, a Leipzig vocational school adopted the name of Karl-Heine-Schule.
References
1819 births
1888 deaths
Businesspeople from Leipzig
People from the Kingdom of Saxony
German Progress Party politicians
Members of the Second Chamber of the Diet of the Kingdom of Saxony
Members of the 2nd Reichstag of the German Empire
German Freemasons
19th-century German lawyers
Jurists from Saxony
|
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "path_to_url">
<plist version="1.0">
<dict>
<key>SchemeUserState</key>
<dict>
<key>3DTouchQuickAction.xcscheme</key>
<dict>
<key>orderHint</key>
<integer>0</integer>
</dict>
</dict>
<key>SuppressBuildableAutocreation</key>
<dict>
<key>9F3052081C5A700E008C3D51</key>
<dict>
<key>primary</key>
<true/>
</dict>
<key>9F30521C1C5A700E008C3D51</key>
<dict>
<key>primary</key>
<true/>
</dict>
<key>9F3052271C5A700E008C3D51</key>
<dict>
<key>primary</key>
<true/>
</dict>
</dict>
</dict>
</plist>
```
|
Vanderhoef is a surname. Notable people with the surname include:
Larry N. Vanderhoef (1941–2015), American biochemist and academic
Marion Vanderhoef (1894–1985), American tennis player
Surnames of Dutch origin
|
A precipitin is an antibody which can precipitate out of a solution upon antigen binding.
Precipitin reaction
The precipitin reaction provided the first quantitative assay for antibody. The precipitin reaction is based upon the interaction of antigen with antibody leading to the production of antigen-antibody complexes.
To produce a precipitin reaction, varying amounts of soluble antigen are added to a fixed amount of serum containing antibody. As the amount of antigen added:
In the zone of antibody excess, each molecule of antigen is bound extensively by antibody and crosslinked to other molecules of antigen. The average size of antibody-antigen complex is small; cross-linking between antigen molecules by antibody is rare.
In the zone of equivalence, the formation of precipitin complexes is optimal. Extensive lattices of antigen and antibody are formed by cross-linking.
At high concentrations of antigen, the average size of antibody-antigen complexes is once again small because few antibody molecules are available to cross-link antigen molecules together.
The small, soluble immune complexes formed in vivo in the zone of antigen excess can cause a variety of pathological syndromes.
Antibody can only precipitate antigenic substrates that are multivalent—that is, only antigens that have multiple antibody-binding sites epitopes. This allows for the formation of large antigen:antibody complexes.
References
External links
Biochemistry detection reactions
Immune system
|
```yaml
# Each section from every release note are combined when the
# CHANGELOG.rst is rendered. So the text needs to be worded so that
# it does not depend on any information only available in another
# section. This may mean repeating some details, but each section
# must be readable independently of the other.
#
# Each section note must be formatted as reStructuredText.
---
fixes:
- |
Silence the misleading error message
``No valid api key found, reporting the forwarder as unhealthy``
from the output of the ``agent check`` command.
```
|
Talamancaheros is a genus of cichlid fish found in fast- and moderately-flowing rivers on the Pacific slope of the Talamanca mountains of Costa Rica and western Panama. Talamancaheros reaches up to in standard length.
Species and taxonomy
Before the genus Talamancaheros was recognized, these species had been placed in several other genera, including Cichlasoma, Heros, Theraps, Tomocichla and others, but they are not particularly closely related to any of these. The nearest relative of Talamancaheros is Isthmoheros tuyrensis.
There are currently two recognized species in this genus:
Talamancaheros sieboldii (Kner, 1863) (Siebold's cichlid)
Talamancaheros underwoodi (Regan, 1906)
Until 2016, T. underwoodi was included as a population of T. sieboldii.
References
Heroini
|
```smalltalk
// The .NET Foundation licenses this file to you under the MIT license.
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
[assembly: HostingStartup(typeof(Microsoft.AspNetCore.Watch.BrowserRefresh.HostingStartup))]
namespace Microsoft.AspNetCore.Watch.BrowserRefresh
{
internal sealed class HostingStartup : IHostingStartup, IStartupFilter
{
public void Configure(IWebHostBuilder builder)
{
builder.ConfigureServices(services => services.TryAddEnumerable(ServiceDescriptor.Singleton<IStartupFilter>(this)));
}
public Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next)
{
return app =>
{
app.MapWhen(
static (context) =>
{
var path = context.Request.Path;
return path.StartsWithSegments(ApplicationPaths.FrameworkRoot) &&
(path.StartsWithSegments(ApplicationPaths.ClearSiteData) ||
path.StartsWithSegments(ApplicationPaths.BlazorHotReloadMiddleware) ||
path.StartsWithSegments(ApplicationPaths.BrowserRefreshJS) ||
path.StartsWithSegments(ApplicationPaths.BlazorHotReloadJS));
},
static app =>
{
app.Map(ApplicationPaths.ClearSiteData, static app => app.Run(context =>
{
// Scoped css files can contain links to other css files. We'll try clearing out the http caches to force the browser to re-download.
// See path_to_url#directives
context.Response.Headers["Clear-Site-Data"] = "\"cache\"";
return Task.CompletedTask;
}));
app.Map(ApplicationPaths.BlazorHotReloadMiddleware, static app => app.UseMiddleware<BlazorWasmHotReloadMiddleware>());
app.Map(ApplicationPaths.BrowserRefreshJS,
static app => app.UseMiddleware<BrowserScriptMiddleware>(BrowserScriptMiddleware.GetBrowserRefreshJS()));
app.Map(ApplicationPaths.BlazorHotReloadJS,
static app => app.UseMiddleware<BrowserScriptMiddleware>(BrowserScriptMiddleware.GetBlazorHotReloadJS()));
});
app.UseMiddleware<BrowserRefreshMiddleware>();
next(app);
};
}
}
}
```
|
```smalltalk
using UnityEngine;
namespace Microsoft.MixedReality.Toolkit.Utilities
{
/// <summary>
/// Component to animate and visualize a box that can be used with
/// per pixel based clipping.
/// </summary>
[ExecuteInEditMode]
[AddComponentMenu("Scripts/MRTK/Core/ClippingBox")]
public class ClippingBox : ClippingPrimitive
{
/// <summary>
/// The property name of the clip box inverse transformation matrix within the shader.
/// </summary>
protected int clipBoxInverseTransformID;
private Matrix4x4 clipBoxInverseTransform;
/// <inheritdoc />
protected override string Keyword
{
get { return "_CLIPPING_BOX"; }
}
/// <inheritdoc />
protected override string ClippingSideProperty
{
get { return "_ClipBoxSide"; }
}
/// <summary>
/// Renders a visual representation of the clipping primitive when selected.
/// </summary>
protected void OnDrawGizmosSelected()
{
if (enabled)
{
Gizmos.matrix = transform.localToWorldMatrix;
Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
}
}
/// <inheritdoc />
protected override void Initialize()
{
base.Initialize();
clipBoxInverseTransformID = Shader.PropertyToID("_ClipBoxInverseTransform");
}
protected override void BeginUpdateShaderProperties()
{
clipBoxInverseTransform = transform.worldToLocalMatrix;
base.BeginUpdateShaderProperties();
}
protected override void UpdateShaderProperties(MaterialPropertyBlock materialPropertyBlock)
{
materialPropertyBlock.SetMatrix(clipBoxInverseTransformID, clipBoxInverseTransform);
}
}
}
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.