text stringlengths 1 22.8M |
|---|
The lesser black krait (Bungarus lividus) is a species of venomous elapid snake found in India, Bangladesh, and Nepal.
The specific epithet is after Latin lividus, meaning “bluish metal-colored” or “lead-colored”, referring to the snake's coloration.
Description
The Lesser black krait is a rather small sized snake. The body (dorsum) is smooth and black to bluish-black in colour. The upper lip is white. The ventrals are white with grey edges.
The eyes are small, black with round pupils. Eyes are positioned more towards the snout.
The scales are arranged in 15 dorsal rows (15:15:15). The mid-dorsal (vertebral) scales are only slightly enlarged than the other rows. Anal and subcaudal scales are undivided. 7 supralabials(3rd & 4th touches eye), 7 infralabials(3rd touches anterior genial); Temporals 1+2; Postocular 2.
Distribution
India(North Bengal, Northeast India), Bangladesh, Nepal
Type locality: Assam, India
Ecology
Feeding
The krait is primarily ophiophagous, meaning it preys on other snakes.
References
Further reading
Boulenger, G.A. 1890. The Fauna of British India, Including Ceylon and Burma. Reptilia and Batrachia. Taylor & Francis. London. xviii, 541 pp.
Cantor, T.E. 1839. Spicilegium serpentium indicorum [parts 1 and 2]. Proc. Zool. Soc. London 7: 31–34, 49–55.
Slowinski, J. B. 1994. A phylogenetic analysis of Bungarus (Elapidae) based on morphological characters. Journal of Herpetology 28(4):440-446.
lividus
Snakes of Asia
Reptiles of Bangladesh
Reptiles of India
Reptiles of Nepal
Reptiles described in 1839
Taxa named by Theodore Edward Cantor |
Dabaihui Plaza () is a supertall skyscraper located in Shenzhen, Guangdong, China. It is tall. Construction began in 2012 and ended in 2021.
See also
List of tallest buildings in Shenzhen
List of tallest buildings in China
List of tallest buildings in the world
References
Skyscraper office buildings in Shenzhen
Buildings and structures under construction in China
Residential skyscrapers in China
Skyscrapers in Shenzhen |
Reina de Corazones is a Venezuelan telenovela written by Humberto 'Kiko' Olivieri and produced by Radio Caracas Televisión in 1998. This telenovela lasted 123 episodes and was distributed internationally by RCTV International.
Emma Rabbe and Roberto Mateos starred as the main protagonists with Dad Dager, Roberto Moll, Daniel Lugo and Kiara as antagonists.
Synopsis
Reina de Corazones is a love story marked by falsehood, rivalry and excessive ambition. Marlene Paez is a beautiful blond surrounded by a kindly aura paradoxical to her firm and determined character. She transcends many levels of pain and misery to reach international success as a model. But fame is not enough, and her empty heart is divided both by her love for Santiago Porras and her search for the truth about her past. Soon, events conspire to draw her back to Topochal, the town of her birth, at the height of her career.
Santiago Porras is a man of great ideals and passions, who, for the love of Marlene, decides to take the road to priesthood after finding out that his father "El Diablo" is the presumed murderer of her parents. Destiny reunites Marlene and Santiago at the funeral of Marlene's stepmother Dolores. As the beautiful Marlene sheds her first tear, the sky explodes with rain, ending a lengthy and severe drought. Sensing that a miracle has occurred, the amazed and beholden townspeople claim Marlene as queen of their hearts.
Time has changed nothing; the passions of these reunited lovers still smolder. But a strong rivalry between two factions in the town, created and led by Ramiro Vegas and Odilo Santos, begins to intrude on their love. And in their battle for power, the two leaders ignore another true love story, that which bonds their adolescent children Julieta and Federico. Once again, political passions and a darkened past between families threaten to obstruct the purity of love.
Though tortured by their past, Marlene and Santiago share a goal: to dissolve the factions and reunite their beloved Topochal. In his crusade for harmony, Santiago recovers property documents that have been lost and returns the land to the original owners. Righting this wrong enables him to shed the cassock's enormous weight. Now a layman, Santiago goes to Marlene with an open heart, but she rejects him because of his earlier abandonment and with holding of the truth about his past.
The dark history of Topochal could happen again unless Marlene and Santiago succeed in their quest to uncover hidden truths and replace rivalry with love. They will have to overcome their disillusionment to achieve what they both really want: unity for themselves and their town.
Cast
Emma Rabbe as Marlene Paez/Sara
Roberto Mateos as Santiago Porras
Ricardo Álamo as Jean Paul
Alberto Alifa as Father Barrientos
César Bencid as Berensejo
Marcos Campos as Matute
Dad Dager as Catalina Monsalve
Dessideria D'Caro as Maria Gracia
Albi De Abreu as Federico
Paola Eagles as Dulce
Freddy Galavis as Juvenal
Javier Gomez as Germán Andueza
Luke Grande as Bartolo
Francisco Guinot as Padre Servillo
Carlos Guillermo Haydon as Adriano Vicentelli
Tomas Henriquez as Fulgencio Cruz
Kiara as Luisa Elena
Maria Luisa Lamata as Socorro
Jeannette Lehr as Elsa
Daniel Lugo as Ramiro Vega
Prakriti Maduro as Dayana
Roberto Moll as Odilo Santos
Denise Novell as Isabela Cotala
Amalia Perez Diaz as Solvencia
Jennifer Rodriguez as Julieta Carolina
Jose Romero as Gandica
Tania Sarabia as Zoila Guerra
Carolina Tejera as Mesalina
Beatriz Valdes as Salomé de Santos
References
External links
Reina de Corazones at the Internet Movie Database
Opening credits
1998 telenovelas
1998 Venezuelan television series debuts
1998 Venezuelan television series endings
RCTV telenovelas
Spanish-language telenovelas
Television shows set in Caracas |
Larisa Nikolayevna Ponomaryova (Russian: Лариса Николаевна Пономарёва; born 1 July 1949) is a Russian politician. She is a former representative of the government of the Chukotka Autonomous Okrug in the Federation Council, serving from 2005 to 2013.
Early life
Larisa Ponomaryova was born on 1 July 1949. She graduated from the Moscow Institute of Electronic Engineering.
Career
From 2000 to 2001, she worked as an assistant to State Duma member Roman Abramovich. After his election as governor of the Chukotka Autonomous Region, Ponomaryova was appointed head of the secretariat of the apparatus of the governor and the government of the autonomous region. She was directly involved in resolving issues coming through the governor's hotline, and also supervised the resettlement of residents to other regions.
On 23 March 2005, Ponomaryova entered the Federation Council as a representative of the executive authority of the Chukotka Autonomous Okrug. In the Federation Council she was a member of the Committee on Social Policy (from April 2005 to April 2006), from April 2006 to January 2008, the First Deputy Chairman of the Committee on Social Policy, from January 2008 to November 2011 - First Deputy Chairman of the Committee on Social Policy and Healthcare, from November 2008 to November 2011 - Member of the Commission on Youth Affairs and Tourism. In November 2011, she again became First Deputy Chairman of the Social Policy Committee.
She departed from the Federation Council in September 2013. She was replaced by Anna Otke.
She was awarded an honorary diploma of the Federation Council.
Personal life
She is married to Doctor of Physical and Mathematical Sciences , (born in 1945). Their son, Ilya Ponomarev, is a former member of the State Duma of the 5th and 6th convocations from the A Just Russia party. Ilya, the only member of the State Duma to vote against Russia's annexation of Crimea, went into exile in 2014. After the start of 2022 Russian invasion of Ukraine, she moved to Warsaw with her husband.
References
1949 births
Living people
Members of the Federation Council of Russia (after 2000)
21st-century Russian women politicians |
The 1888 Dublin University by-election was a parliamentary by-election held for the United Kingdom House of Commons constituency of Dublin University on 3 February 1888. When one of the members in this two-seat constituency, Dodgson Hamilton Madden, was appointed Solicitor-General for Ireland, the rule at the time required him to submit to re-election. Madden was the only candidate in the by-election and was therefore elected unopposed.
References
1888 elections in the United Kingdom
By-elections to the Parliament of the United Kingdom in Dublin University
Unopposed ministerial by-elections to the Parliament of the United Kingdom in Irish constituencies
February 1888 events
1888 elections in Ireland |
Tosunlu is a common village name used in Turkey. It can refer to:
Tosunlu, Ardanuç
Tosunlu, Aşkale
Tosunlar, Çayırlı
Tosunlar, Devrek
Tosunlu, Karayazı
Tosunlu, Kayapınar
Tosunlu, Karkamış
Tosunlu, Kızıltepe
Tosunlu, Nizip |
```objective-c
/*
* PROGRAM: JRD Access Method
* MODULE: flu_proto.h
* DESCRIPTION: Prototype header file for flu.cpp, functions.cpp,
* builtin.cpp and qatest.cpp
*
* The contents of this file are subject to the Interbase Public
*
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
*
* The Original Code was created by Inprise Corporation
* and its predecessors. Portions created by Inprise Corporation are
*
* All Rights Reserved.
* Contributor(s): ______________________________________.
*/
#ifndef JRD_FLU_PROTO_H
#define JRD_FLU_PROTO_H
FPTR_INT BUILTIN_entrypoint(const TEXT*, const TEXT*);
FPTR_INT FUNCTIONS_entrypoint(const char*, const char*);
#endif // JRD_FLU_PROTO_H
``` |
The 32nd World Orienteering Championships were held in Inverness, Scotland, United Kingdom.
Results
Men
Sprint
4.1 km, 23 controls
Middle
6.2 km, 25 controls
Long
15.4 km, 32 controls
Relay
Women
Sprint
3.8 km, 21 controls
Middle
5.3 km, 21 controls
Long
9.7 km, 19 controls
Relay
Mixed
Sprint relay
References
World Orienteering Championships
2015 in Scottish sport
International sports competitions hosted by Scotland
Sport in Inverness
August 2015 sports events in the United Kingdom
Orienteering in Scotland
21st century in Inverness
2015 in orienteering |
Agrimonia gryposepala (commonly known as tall hairy agrimony, common agrimony, hooked agrimony, or tall hairy grooveburr<ref>[https://www.itis.gov/servlet/SingleRpt/SingleRpt?search_topic=TSN&search_value=25095 ITIS Standard Report Page: Agrimonia gryposepala] Retrieved 2010-03-13.</ref>) is a small perennial flowering plant of the rose family (Rosaceae), which is native to North America. This plant was used by various indigenous peoples to treat medical problems such as diarrhea and fever.
Name and description
The plant grows 1–5 ft (about 30–150 cm) high, producing a cluster of small, yellow, 5-parted flowers on a hairy stalk above pinnate leaves. The fruits are hooked dry seeds grouped in a cluster. A spicy scent is released when the stem is crushed.Robert W. Freckmann Herbarium University of Wisconsin - Stevens Point Retrieved 2010-03-13. The plant's native range covers most of the United States and Canada (except the Rocky Mountains) and extending south to Chiapas, Mexico. It grows in woodlands and forests.
The specific epithet, gryposepala, is derived from the Greek grypos, meaning curved or hooked, and from sepala, meaning sepal. The name "grooveburr," which is sometimes applied to the plant, comes from the grooved shape of the seedpod or burr.
Conservation status in the United States
It is listed as threatened in Kentucky.
Uses
Across North America, various indigenous peoples used the plant for medicinal purposes. Among the Iroquois people, a drink made from the roots of the plant was used for diarrhea. Among the Cherokee, the plant was used for the same purpose, to reduce fever, and for a range of other problems. The Ojibwe used the plant for urinary problems, and the Meskwaki and Prairie Potawatomi used it as a styptic for nosebleeds.
These ethnobotanical uses of the plant have some similarities to the traditional medical uses of Agrimonia eupatoria'', which is native to Europe, Asia, and Africa.
References
External links
California Native Plant Link Exchange: Plants that Grow with Agrimonia gryposepala.
gryposepala
Plants used in traditional Native American medicine
Plants described in 1842
Flora of Western Canada
Flora of Eastern Canada
Flora of the United States
Taxa named by Karl Friedrich Wilhelm Wallroth |
Timothy Derijck (born 25 May 1987) is a Belgian professional footballer who plays as a centre-back for Challenger Pro League club Zulte Waregem.
Club career
Early career
Derijck is a product of the Anderlecht youth academy, but left the Brussels giants for Feyenoord before making it into the first team. He also wore the jerseys of Dender and NAC Breda before joining ADO Den Haag in January 2009. It was where he developed himself into one of the most consistent defenders in the Eredivisie.
PSV Eindhoven
On 15 August 2011, PSV Eindhoven announced the signing of Derijck on a four-year contract from ADO Den Haag for a fee of €750,000. He was given the number 18 shirt. He made his debut on 21 August 2011 in PSV's 3–0 win over his former club Den Haag. He scored his first competitive goal for PSV in a 3–2 win over Achilles '29 on 27 September in the 2012–13 KNVB Beker. His first Eredivise goal for PSV was an equalizer against PEC Zwolle on 28 October 2012.
On 19 July 2013, it was announced that Derijck was sent on loan to FC Utrecht until the end of the season.
Return to ADO Den Haag
On 26 August 2014, Derijck returned to his former club ADO Den Haag. He signed a two-year deal on a free transfer.
Zulte Waregem
In June 2016, Derijck joined Belgian side Zulte Waregem.
Gent
In August 2018, Derijck joined Gent.
Return to Zulte Waregem
On 6 January 2022, Derijck returned to Zulte Waregem on a one-year contract, with an option for a second year. He returned to the pitch as a starter for Waregem in a 0–0 home draw against Oostende on 9 February. Derijck was a starter for the club for the remainder of the 2021–22 season, but saw himself increasingly demoted to the bench after suffering some injuries early on in the 2022–23 season as Modou Tambedou and Borja López were preferred at centre-back under new head coach Mbaye Leye. In October and November 2022, Lukas Willen also surpassed Derijck in the depth chart.
International career
On 5 September 2011, he received his first call up to the senior Belgium national team for the friendly match against the United States. Coach Georges Leekens called him to replace the injured Jan Vertonghen. However, he was an unused substitute in a 1–1 draw.
Honours
Zulte Waregem
Belgian Cup: 2016–17
PSV Eindhoven
KNVB Cup: 2011–12
Johan Cruyff Shield: 2012
References
External links
Voetbal International profile
Belgium Stats at Belgian FA
Living people
1987 births
Men's association football central defenders
Belgian men's footballers
Belgian expatriate men's footballers
Belgium men's under-21 international footballers
Belgium men's youth international footballers
Eerste Divisie players
Feyenoord players
NAC Breda players
F.C.V. Dender E.H. players
ADO Den Haag players
PSV Eindhoven players
Jong PSV players
FC Utrecht players
S.V. Zulte Waregem players
K.A.A. Gent players
K.V. Kortrijk players
Belgian Pro League players
Eredivisie players
Challenger Pro League players
Expatriate men's footballers in the Netherlands
Belgian expatriate sportspeople in the Netherlands |
Ulva crassa is a species of blackish-green coloured seaweed in Ulvaceae family that is endemic to New Zealand. The name comes from Latin meaning thick.
References
Further reading
Ulvaceae
Plants described in 1956
Endemic flora of New Zealand |
Balnaguard Halt railway station served the hamlet of Balnaguard, Perth and Kinross, Scotland from 1935 to 1965 on the Inverness and Perth Junction Railway.
History
The station opened on 2 December 1935 by the London, Midland and Scottish Railway. It closed on 3 May 1965.
References
External links
Disused railway stations in Perth and Kinross
Railway stations in Great Britain opened in 1935
Railway stations in Great Britain closed in 1965
Beeching closures in Scotland
1935 establishments in Scotland
1965 disestablishments in Scotland
Former London, Midland and Scottish Railway stations |
Frank Sánchez Faure (born 18 July 1992) is a Cuban professional boxer who has held the NABO heavyweight title since 2019 and the WBC Continental Americas heavyweight title since 2020.
Professional career
Sánchez made his professional debut on 22 September 2017, scoring a first-round technical knockout (TKO) victory against Justin Thornton at the Mel Ott Recreation Center in Gretna, Louisiana.
After winning his first six fights, all by stoppage, he faced Lamont Capers on 4 May 2018. Capers received a point deduction in the first round for excessive holding before the contest was halted in the second round after Capers was shoved through the ropes and out of the ring. With capers not able to continue, the bout was scored a no contest (NC).
Following six more wins, four by stoppage, Sánchez faced Victor Bisbal for the vacant WBO-NABO heavyweight title on 31 August 2019 at the Minneapolis Armory in Minneapolis, Minnesota. Sánchez defeated Bisbal via fourth-round corner retirement (RTD) after Bisbal's corner informed referee Celestino Ruiz that Bisbal was unwilling to continue before the start of the fifth round. After Efe Ajagba pulled out of a bout with Jack Mulowayi due to a back injury sustained during training, Sánchez was brought in as a late replacement. The bout took place on 26 October at the Santander Arena in Reading, Pennsylvania. Sánchez won a shutout unanimous decision (UD) to capture the vacant WBO-NABO title for a second time, with all three judges scoring the bout 100–90. His next fight came against Joey Dawejko for the vacant WBC Continental Americas heavyweight title on 7 March 2020 at the Barclays Center in New York City. Sánchez captured his second professional title via UD over ten rounds, with two judges scoring the bout 100–90 and the third scoring it 98–92.
Following his win against Dawejko, Sánchez recorded back-to-back knockout wins against Brian Howard and Julian Fernandez, before facing Nagy Aguilera on the undercard of Canelo Álvarez vs. Billy Joe Saunders on 8 May 2021. Sánchez won the bout by unanimous technical decision after six rounds, after Aguilera told officials that he was not able to continue after an unintentional foul.
Sánchez faced undefeated Efe Ajagba on 9 October 2021 on the undercard of Tyson Fury vs. Deontay Wilder III. Sánchez knocked down Ajagba en route to a unanimous decision victory, with scores of 98–91, 98–91 and 97–92.
Sánchez was expected to face Carlos Negrón on 1 January 2022, on the undercard of the Luis Ortiz and Charles Martin heavyweight bout. It was announced on 28 December 2021 that Negrón had withdrawn from the bout due to a positive COVID-19 test, and would be replaced by Christian Hammer. Sánchez won the fight by unanimous decision. He was awarded every single round of the fight, and scored a debatable knockdown in the tenth round.
Professional boxing record
References
Living people
1992 births
Cuban male boxers
Sportspeople from Guantánamo
Heavyweight boxers
21st-century Cuban people |
The harlequin beetle (Acrocinus longimanus) is a large and distinctly colored species of longhorn beetle from the Neotropics and the only member of the genus Acrocinus.
It is given its English name because of the elaborate pattern of black, orange-red and greenish-yellow markings in both sexes; despite this the beetle is quite well-camouflaged when perched on a lichen or fungus covered tree trunk. The species name longimanus is a Latin word that refers to the extremely long forelegs (manus) of the large males, which are longer than the beetle's entire body. The head-and-body of this beetle measures long. The size and unusual appearance of the harlequin beetle has made it popular among insect collectors. Although essentially harmless to humans, it may bite in self-defense with its strong mandibles.
Taxonomy
The harlequin beetle was first scientifically described as Cerambyx longimanus by Linnaeus in the 10th edition of Systema Naturae in 1758. In 1806, it was moved to the newly coined genus Acrocinus by Illiger. Although recent authorities have consistently recognized it as the only member of this genus, the relationship to other genera of longhorned beetles has not been clear: It has been disputed whether the tribe Acrocinini only should include the genus Acrocinus or it also include a few other genera. Recent authorities have often considered Acrocinini as monotypic, but an analysis of morphological characters indicates that Macropophora and Oreodera are sufficiently close to also be included in this tribe.
Despite the very large distribution of the harlequin beetle, both morphological and genetic evidence supports its status as a single widespread species rather than a cryptic species complex.
Distribution and habitat
The harlequin beetle is found in tropical and subtropical parts of the Americas, ranging from Mexico, through Central and South America, south as far as northernmost Argentina (Corrientes and Misiones), southernmost Brazil (Rio Grande do Sul) and Paraguay. It also occurs on the Caribbean island nation of Trinidad and Tobago, but a record from Barbados is considered erroneous. The harlequin beetle has been recorded from all Central American countries and all South American countries, except Chile and Uruguay. In Mexico, its distribution is incompletely known, but it is found in the south of the country, ranging north along the Pacific slope to Colima and along the Caribbean slope to Hidalgo; it is not known from the Yucatán Peninsula.
The harlequin beetle is locally common and while most records are from undisturbed forests, it also occurs in secondary forest and occasionally even in cities if there are green areas nearby. Most of its South American range is in the Amazon and Atlantic forests, but it also occurs more locally in the Cerrado and Caatinga, and in the northwestern part of the continent it occurs in both humid and fairly dry lowland and highland forests on both sides of the Andes, in interandean valles and the coastal Caribbean region. It has been recorded at elevations up to above sea level.
Sexual dimorphism and behavior
Male and female harlequin beetles have similar color patterns and reach a similar body size, but the species is sexually dimorphic in the foreleg length and shape: In large males, the forelegs are greatly extended, up to long, being twice the length as in females with the same body size. Large males also exhibit strong curvature in their foreleg tibiae, which is not seen in females. However, in small males, both length and shape of the forelegs resemble that seen in small females. These traits aid the males as they fight with each other over optimal egg deposition sites in preparation for mating. Males engage each other with their forelimbs in an attempt to flip other males off of the dead or dying trees that may be chosen by females to provide food for developing larvae. The males also readily attempt to bite each other with their strong mandibles, sometimes biting off pieces of the opponents antennae or legs. Once a site has been secured, the male will guard it around the clock, but females typically only are present during nighttime; once a female arrives, the male will also guard her.
Harlequin beetles mainly fly during the night and appear to be able to rapidly locate recently fallen trees through the smell of the large amounts of sap that is released when it happens. They are also attracted to artificial light during the night. The females prefer to lay their eggs on recently fallen trees, but may also use trees that have fallen up to a few months ago but not yet decayed, dead sections of living trees, or weakened living trees. When using trees that are still alive, they are occasionally regarded as a pest, but otherwise harlequin beetles play an important role in the early phase of decomposition of dead wood, also creating habitats for other saproxylic species. Mating and egg-laying mostly happens at dusk or dawn, and a wide range of tree species are used, including Artocarpus, Bagassa guianensis, Brosimum alicastrum (breadnut) and others in the genus Brosimum, Caryocar (souari trees), Castilla elastica (Panama rubber tree), Ceiba, Clarisia, Couma, Enterolobium, Eucalyptus (not native to the Americas but widely introduced), Ficus (fig trees), Guazuma, Inga, Lonchocarpus, Maclura, Parahancornia, Perebea, Persea and Theobroma cacao (cocoa tree). The female uses her strong mandibles to make several circular, elliptical or crescent-shaped holes (diameter or maximum length ) in the bark; the holes are typically placed at regular intervals and as if on a string, forming a distinct pattern on the tree. The female places a single egg in each hole and she will typically lay 15–20 eggs over a period of several hours or a few days; a female may lay up to a total of 160 eggs. After an egg hatches, the wood is used as a food source by the larvae, which makes a network of tunnels inside it. Just before pupating, the larvae can be around long. From the egg is laid to emergence from the wood as an adult beetle takes 4 to 12 months, or possibly even up to 2 years. Although the harlequin beetle is very rarely maintained in captivity, it has been successfully raised and bred for several generations using either freshly cut wood from Morus (mulberry), or an artificially composite of Morus sawdust, a commercial mixture used for insect rearing and morin suspended in agar, as a larval food source.
The adult beetles can live up to about half a year, and they will feed on sap, wood, fungi and occasionally animal droppings. There is a level of seasonality in the species; adult beetles can be seen year-round, but they are most abundant in the first few months of the rainy season.
Relationship with pseudoscorpions
Tiny pseudoscorpions may attach themselves or hide under the wing coverts of harlequin beetles to use them for transport, which is a form of phoresy. In one case, fifteen pseudoscorpion had hidden themselves under the wing coverts of a harlequin beetle, but their combined weight was still less than 2.5% of the beetle's. Some pseudoscorpion species appear to primarily, or exclusively, rely on harlequin beetles for dispersal between their habitats. Once transported to a recently fallen tree by harlequin beetles, a new pseudoscorpion colony is formed and remains isolated until the next generation of harlequin beetles have completed their immature stages (egg, larvae and pupae) in the wood and emerge as adult beetles. At that point, pseudoscorpions from the colony will attach themselves to the emerging beetles to be transported to a new recently fallen tree, starting the cycle over again.
Anti-fungal properties
The harlequin beetle contains three homologous peptides, Alo-1, Alo-2, and Alo-3. Alo-3 was the first known peptide from insects to exhibit the knottin fold. It has a higher level of activity against the fungal species Candida glabrata than the Alo-1 and Alo-2 peptides do. Currently, there is a lack of treatment for fatal hospital-acquired infections and other pathologies. The peptide Alo-3 found in Harlequin beetles could provide a treatment for these severe, life threatening infections.
References
External links
Beetles described in 1758
Beetles of South America
Lamiinae
Taxa named by Carl Linnaeus |
Laurens van der Hem (1621–1678), was a Dutch lawyer and a collector of maps and landscape prints. He is known today for commissioning his meticulously thorough personal version of the Atlas Maior, itself a major work of cartography and art published by his contemporary and friend Joan Blaeu.
Biography
Van der Hem was born in Amsterdam as the son of the lawyer Ysbrand van der Hem and his wife Geertrui Spiegel, the daughter of the poet Hendrik Laurenszoon Spiegel. His uncles on his father's side were famous in their own right; his uncle Herman was a gifted draughtsman, uncle Hendrik became a lawyer who acquired a large library, and uncle Arend was knighted by Ferdinand II in 1620, and called himself Jonker Arnold van der Hem, Ridder, Heer van Nedersteyn, Corl en Hilteprant.
According to the Netherlands Institute for Art History (RKD), Van der Hem travelled in Italy, and on his return married and settled on the Herengracht, an elite residential area on one of the three major canals of Amsterdam. There he collected the material he used to supplement his personal copy of the Atlas Maior. His copy of the atlas is now known as the Eugenius-atlas or the Atlas Blauw-van der Hem and is today kept at the Austrian National Library in Vienna.
Blaeu's Atlas Maior
The Atlas Maior was popular in Amsterdam when it was published in installments starting in 1649 (last volume in 1673) in 11 gold-embossed volumes. To save money, collectors could purchase it plain without handpainted embellishments. However, Laurens van der Hem went a step further and ordered his maps unbound, and proceeded to have Blaeu's best professional map-finisher, Dirk Jansz van Santen, colour them by hand.
The eleven volumes of Blaeu's atlas form the main body of the Van der Hem's personal copy, but they also include a number of additions including a volume of secret maps created by the Dutch East India Company (VOC) that were never part of the original publication. Van der Hem's entire collection consists of 46 volumes with four supplements and a portfolio of loose maps, which together include over 2,400 full colour maps and drawings of ports, towers, and landscapes by renowned Dutch artists such as Andries Beeckman, Gaspar Bouttats, Jan Peeters I, Bonaventura Peeters the Elder, Jacques Callot and Cornelis Gerritsz Decker.
Some artists who travelled and brought back drawings made on their travels also had their works included, such as Lambert Doomer, Jan Hackaert, Adriaen Matham, Roelant Savery, Willem Schellinks, and Reinier Nooms, also named as 'Zeeman'. Southwest France was drawn by Laurens' brother Herman, who died a bachelor in Bordeaux. Drawings of Italy and Sicily were described by Van der Helm himself.
Curiosity cabinet
Van der Hem's unique map collection became something of a tourist attraction during his lifetime, and several famous people who visited Amsterdam at the time also visited Van der Hem's home to view the collection. One of these was Cosimo III, the Grand Duke of Tuscany, who visited the Herengracht on 2 January 1668.
On 9 March 1711, the German travelling scholar Zacharias Conrad von Uffenbach paid a visit to Laurens' daughter Agatha (Jungfer van der Gemm) to view her Blauischen Atlas, for which the Comte d'Avaux had offered her 20,000 guilders, but which she valued at 50,000 guilders. Conrad von Uffenbach was reportedly highly impressed by the colouring done by the master he referred to as "Dirck Janssen van Santen".
Eugenius atlas
After Van der Hem's death in 1678, the atlas was inherited by his wife and after her death by his daughter Agatha and then his other daughter Agnes. After Agnes' death in 1712, Van der Hem's grandson sold it in an auction in 1730 to Prince Eugene of Savoy, a stadtholder in the Austrian-controlled Southern Netherlands, for 22,000 florins. After the purchase, the atlas came to be known as the Eugenius-atlas. Prince Eugene transported it to Vienna where it remains to this day, and is one of the prized possessions in the collection of the Austrian National Library.
The atlas was nearly lost in a fire in 1992 and has since been digitised and added to the UNESCO Memory of the World Register in 2003. In 2011 a facsimile project was completed.
References
External links
Dutch documentary on the Atlas Blauw-van der Hem
"Makian As It Appears from the Side of Ngofakiaha" with biographical information about van der Hem
1621 births
1678 deaths
Art collectors from Amsterdam
Lawyers from Amsterdam
17th-century Dutch lawyers |
Homer Le Grand Lyon (March 1, 1879 – May 31, 1956) was a U.S. Representative from North Carolina.
Born in Elizabethtown, North Carolina, Lyon attended the public schools, the Davis Military School, Winston, North Carolina, and the law department of the University of North Carolina at Chapel Hill.
He was admitted to the bar in 1900 and commenced practice in Whiteville, North Carolina.
He served as delegate to every Democratic State convention from 1901 to 1921.
He served as delegate to the Democratic National Conventions in 1904 and 1940.
He served as solicitor of the eighth judicial district of North Carolina 1913-1920.
Lyon was elected as a Democrat to the Sixty-seventh and to the three succeeding Congresses (March 4, 1921 – March 3, 1929).
He was not a candidate for renomination in 1928.
He resumed the practice of law in Whiteville, North Carolina, until his retirement in 1950.
He died in Whiteville, North Carolina, May 31, 1956.
He was interred in Memorial Cemetery.
Sources
1879 births
1956 deaths
Democratic Party members of the United States House of Representatives from North Carolina
University of North Carolina School of Law alumni
People from Elizabethtown, North Carolina
People from Whiteville, North Carolina |
```php
<?php
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
*/
namespace Google\Service\Dfareporting;
class MobileCarrier extends \Google\Model
{
/**
* @var string
*/
public $countryCode;
/**
* @var string
*/
public $countryDartId;
/**
* @var string
*/
public $id;
/**
* @var string
*/
public $kind;
/**
* @var string
*/
public $name;
/**
* @param string
*/
public function setCountryCode($countryCode)
{
$this->countryCode = $countryCode;
}
/**
* @return string
*/
public function getCountryCode()
{
return $this->countryCode;
}
/**
* @param string
*/
public function setCountryDartId($countryDartId)
{
$this->countryDartId = $countryDartId;
}
/**
* @return string
*/
public function getCountryDartId()
{
return $this->countryDartId;
}
/**
* @param string
*/
public function setId($id)
{
$this->id = $id;
}
/**
* @return string
*/
public function getId()
{
return $this->id;
}
/**
* @param string
*/
public function setKind($kind)
{
$this->kind = $kind;
}
/**
* @return string
*/
public function getKind()
{
return $this->kind;
}
/**
* @param string
*/
public function setName($name)
{
$this->name = $name;
}
/**
* @return string
*/
public function getName()
{
return $this->name;
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(MobileCarrier::class, 'Google_Service_Dfareporting_MobileCarrier');
``` |
Career
Luke William Peter Wells (born 29 December 1990) is an English cricketer who plays for Lancashire, having previously played for Sussex for 10 years. A left-handed top order batter and occasional right-arm legspin bowler, he made his debut at the end of the 2010 season.
He joined Lancashire in November 2020 having been released by Sussex.
Wells is the son of former England player Alan Wells, and the nephew of Colin Wells, both of whom also played for Sussex.
Luke was awarded his Lancashire cap in September 2022.
The Hundred
He made his debut in the Hundred in August 2023 for Welsh Fire, making 57 on his debut in a rain shortened game and being awarded man of the match.
References
External links
Living people
1990 births
Sussex cricketers
Cricketers from Eastbourne
English cricketers
Colombo Cricket Club cricketers
People educated at St Bede's School, Hailsham
Lancashire cricketers
Welsh Fire cricketers |
Agriomorpha fusca is common species of damselfly in the flatwing damselfly family Rhipidolestidae. It is commonly known as the Chinese yellowface. Agriomorpha fusca rest with its wings folded while many related damselfies rest with their wings spread flat. This species is found in China (Guangdong, Guangxi, Hong Kong, and Hainan).
References
Calopterygoidea
Insects described in 1933 |
```html
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<HTML>
<HEAD>
<TITLE>Lua 5.4 Reference Manual</TITLE>
<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
<LINK REL="stylesheet" TYPE="text/css" HREF="manual.css">
<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
</HEAD>
<BODY>
<H1>
<A HREF="path_to_url"><IMG SRC="logo.gif" ALT="Lua"></A>
Lua 5.4 Reference Manual
</H1>
<P>
by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
<P>
<SMALL>
Freely available under the terms of the
<a href="path_to_url">Lua license</a>.
</SMALL>
<DIV CLASS="menubar">
<A HREF="contents.html#contents">contents</A>
·
<A HREF="contents.html#index">index</A>
·
<A HREF="path_to_url">other versions</A>
</DIV>
<!-- ====================================================================== -->
<p>
<!-- $Id: manual.of $ -->
<h1>1 – <a name="1">Introduction</a></h1>
<p>
Lua is a powerful, efficient, lightweight, embeddable scripting language.
It supports procedural programming,
object-oriented programming, functional programming,
data-driven programming, and data description.
<p>
Lua combines simple procedural syntax with powerful data description
constructs based on associative arrays and extensible semantics.
Lua is dynamically typed,
runs by interpreting bytecode with a register-based
virtual machine,
and has automatic memory management with
a generational garbage collection,
making it ideal for configuration, scripting,
and rapid prototyping.
<p>
Lua is implemented as a library, written in <em>clean C</em>,
the common subset of Standard C and C++.
The Lua distribution includes a host program called <code>lua</code>,
which uses the Lua library to offer a complete,
standalone Lua interpreter,
for interactive or batch use.
Lua is intended to be used both as a powerful, lightweight,
embeddable scripting language for any program that needs one,
and as a powerful but lightweight and efficient stand-alone language.
<p>
As an extension language, Lua has no notion of a "main" program:
it works <em>embedded</em> in a host client,
called the <em>embedding program</em> or simply the <em>host</em>.
(Frequently, this host is the stand-alone <code>lua</code> program.)
The host program can invoke functions to execute a piece of Lua code,
can write and read Lua variables,
and can register C functions to be called by Lua code.
Through the use of C functions, Lua can be augmented to cope with
a wide range of different domains,
thus creating customized programming languages sharing a syntactical framework.
<p>
Lua is free software,
and is provided as usual with no guarantees,
as stated in its license.
The implementation described in this manual is available
at Lua's official web site, <code>www.lua.org</code>.
<p>
Like any other reference manual,
this document is dry in places.
For a discussion of the decisions behind the design of Lua,
see the technical papers available at Lua's web site.
For a detailed introduction to programming in Lua,
see Roberto's book, <em>Programming in Lua</em>.
<h1>2 – <a name="2">Basic Concepts</a></h1>
<p>
This section describes the basic concepts of the language.
<h2>2.1 – <a name="2.1">Values and Types</a></h2>
<p>
Lua is a dynamically typed language.
This means that
variables do not have types; only values do.
There are no type definitions in the language.
All values carry their own type.
<p>
All values in Lua are first-class values.
This means that all values can be stored in variables,
passed as arguments to other functions, and returned as results.
<p>
There are eight basic types in Lua:
<em>nil</em>, <em>boolean</em>, <em>number</em>,
<em>string</em>, <em>function</em>, <em>userdata</em>,
<em>thread</em>, and <em>table</em>.
The type <em>nil</em> has one single value, <b>nil</b>,
whose main property is to be different from any other value;
it often represents the absence of a useful value.
The type <em>boolean</em> has two values, <b>false</b> and <b>true</b>.
Both <b>nil</b> and <b>false</b> make a condition false;
they are collectively called <em>false values</em>.
Any other value makes a condition true.
Despite its name,
<b>false</b> is frequently used as an alternative to <b>nil</b>,
with the key difference that <b>false</b> behaves
like a regular value in a table,
while a <b>nil</b> in a table represents an absent key.
<p>
The type <em>number</em> represents both
integer numbers and real (floating-point) numbers,
using two subtypes: <em>integer</em> and <em>float</em>.
Standard Lua uses 64-bit integers and double-precision (64-bit) floats,
but you can also compile Lua so that it
uses 32-bit integers and/or single-precision (32-bit) floats.
The option with 32 bits for both integers and floats
is particularly attractive
for small machines and embedded systems.
(See macro <code>LUA_32BITS</code> in file <code>luaconf.h</code>.)
<p>
Unless stated otherwise,
any overflow when manipulating integer values <em>wrap around</em>,
according to the usual rules of two-complement arithmetic.
(In other words,
the actual result is the unique representable integer
that is equal modulo <em>2<sup>n</sup></em> to the mathematical result,
where <em>n</em> is the number of bits of the integer type.)
<p>
Lua has explicit rules about when each subtype is used,
but it also converts between them automatically as needed (see <a href="#3.4.3">§3.4.3</a>).
Therefore,
the programmer may choose to mostly ignore the difference
between integers and floats
or to assume complete control over the representation of each number.
<p>
The type <em>string</em> represents immutable sequences of bytes.
Lua is 8-bit clean:
strings can contain any 8-bit value,
including embedded zeros ('<code>\0</code>').
Lua is also encoding-agnostic;
it makes no assumptions about the contents of a string.
The length of any string in Lua must fit in a Lua integer.
<p>
Lua can call (and manipulate) functions written in Lua and
functions written in C (see <a href="#3.4.10">§3.4.10</a>).
Both are represented by the type <em>function</em>.
<p>
The type <em>userdata</em> is provided to allow arbitrary C data to
be stored in Lua variables.
A userdata value represents a block of raw memory.
There are two kinds of userdata:
<em>full userdata</em>,
which is an object with a block of memory managed by Lua,
and <em>light userdata</em>,
which is simply a C pointer value.
Userdata has no predefined operations in Lua,
except assignment and identity test.
By using <em>metatables</em>,
the programmer can define operations for full userdata values
(see <a href="#2.4">§2.4</a>).
Userdata values cannot be created or modified in Lua,
only through the C API.
This guarantees the integrity of data owned by
the host program and C libraries.
<p>
The type <em>thread</em> represents independent threads of execution
and it is used to implement coroutines (see <a href="#2.6">§2.6</a>).
Lua threads are not related to operating-system threads.
Lua supports coroutines on all systems,
even those that do not support threads natively.
<p>
The type <em>table</em> implements associative arrays,
that is, arrays that can have as indices not only numbers,
but any Lua value except <b>nil</b> and NaN.
(<em>Not a Number</em> is a special floating-point value
used by the IEEE 754 standard to represent
undefined numerical results, such as <code>0/0</code>.)
Tables can be <em>heterogeneous</em>;
that is, they can contain values of all types (except <b>nil</b>).
Any key associated to the value <b>nil</b> is not considered part of the table.
Conversely, any key that is not part of a table has
an associated value <b>nil</b>.
<p>
Tables are the sole data-structuring mechanism in Lua;
they can be used to represent ordinary arrays, lists,
symbol tables, sets, records, graphs, trees, etc.
To represent records, Lua uses the field name as an index.
The language supports this representation by
providing <code>a.name</code> as syntactic sugar for <code>a["name"]</code>.
There are several convenient ways to create tables in Lua
(see <a href="#3.4.9">§3.4.9</a>).
<p>
Like indices,
the values of table fields can be of any type.
In particular,
because functions are first-class values,
table fields can contain functions.
Thus tables can also carry <em>methods</em> (see <a href="#3.4.11">§3.4.11</a>).
<p>
The indexing of tables follows
the definition of raw equality in the language.
The expressions <code>a[i]</code> and <code>a[j]</code>
denote the same table element
if and only if <code>i</code> and <code>j</code> are raw equal
(that is, equal without metamethods).
In particular, floats with integral values
are equal to their respective integers
(e.g., <code>1.0 == 1</code>).
To avoid ambiguities,
any float used as a key that is equal to an integer
is converted to that integer.
For instance, if you write <code>a[2.0] = true</code>,
the actual key inserted into the table will be the integer <code>2</code>.
<p>
Tables, functions, threads, and (full) userdata values are <em>objects</em>:
variables do not actually <em>contain</em> these values,
only <em>references</em> to them.
Assignment, parameter passing, and function returns
always manipulate references to such values;
these operations do not imply any kind of copy.
<p>
The library function <a href="#pdf-type"><code>type</code></a> returns a string describing the type
of a given value (see <a href="#pdf-type"><code>type</code></a>).
<h2>2.2 – <a name="2.2">Environments and the Global Environment</a></h2>
<p>
As we will discuss further in <a href="#3.2">§3.2</a> and <a href="#3.3.3">§3.3.3</a>,
any reference to a free name
(that is, a name not bound to any declaration) <code>var</code>
is syntactically translated to <code>_ENV.var</code>.
Moreover, every chunk is compiled in the scope of
an external local variable named <code>_ENV</code> (see <a href="#3.3.2">§3.3.2</a>),
so <code>_ENV</code> itself is never a free name in a chunk.
<p>
Despite the existence of this external <code>_ENV</code> variable and
the translation of free names,
<code>_ENV</code> is a completely regular name.
In particular,
you can define new variables and parameters with that name.
Each reference to a free name uses the <code>_ENV</code> that is
visible at that point in the program,
following the usual visibility rules of Lua (see <a href="#3.5">§3.5</a>).
<p>
Any table used as the value of <code>_ENV</code> is called an <em>environment</em>.
<p>
Lua keeps a distinguished environment called the <em>global environment</em>.
This value is kept at a special index in the C registry (see <a href="#4.3">§4.3</a>).
In Lua, the global variable <a href="#pdf-_G"><code>_G</code></a> is initialized with this same value.
(<a href="#pdf-_G"><code>_G</code></a> is never used internally,
so changing its value will affect only your own code.)
<p>
When Lua loads a chunk,
the default value for its <code>_ENV</code> variable
is the global environment (see <a href="#pdf-load"><code>load</code></a>).
Therefore, by default,
free names in Lua code refer to entries in the global environment
and, therefore, they are also called <em>global variables</em>.
Moreover, all standard libraries are loaded in the global environment
and some functions there operate on that environment.
You can use <a href="#pdf-load"><code>load</code></a> (or <a href="#pdf-loadfile"><code>loadfile</code></a>)
to load a chunk with a different environment.
(In C, you have to load the chunk and then change the value
of its first upvalue; see <a href="#lua_setupvalue"><code>lua_setupvalue</code></a>.)
<h2>2.3 – <a name="2.3">Error Handling</a></h2>
<p>
Several operations in Lua can <em>raise</em> an error.
An error interrupts the normal flow of the program,
which can continue by <em>catching</em> the error.
<p>
Lua code can explicitly raise an error by calling the
<a href="#pdf-error"><code>error</code></a> function.
(This function never returns.)
<p>
To catch errors in Lua,
you can do a <em>protected call</em>,
using <a href="#pdf-pcall"><code>pcall</code></a> (or <a href="#pdf-xpcall"><code>xpcall</code></a>).
The function <a href="#pdf-pcall"><code>pcall</code></a> calls a given function in <em>protected mode</em>.
Any error while running the function stops its execution,
and control returns immediately to <code>pcall</code>,
which returns a status code.
<p>
Because Lua is an embedded extension language,
Lua code starts running by a call
from C code in the host program.
(When you use Lua standalone,
the <code>lua</code> application is the host program.)
Usually, this call is protected;
so, when an otherwise unprotected error occurs during
the compilation or execution of a Lua chunk,
control returns to the host,
which can take appropriate measures,
such as printing an error message.
<p>
Whenever there is an error,
an <em>error object</em>
is propagated with information about the error.
Lua itself only generates errors whose error object is a string,
but programs may generate errors with
any value as the error object.
It is up to the Lua program or its host to handle such error objects.
For historical reasons,
an error object is often called an <em>error message</em>,
even though it does not have to be a string.
<p>
When you use <a href="#pdf-xpcall"><code>xpcall</code></a> (or <a href="#lua_pcall"><code>lua_pcall</code></a>, in C)
you may give a <em>message handler</em>
to be called in case of errors.
This function is called with the original error object
and returns a new error object.
It is called before the error unwinds the stack,
so that it can gather more information about the error,
for instance by inspecting the stack and creating a stack traceback.
This message handler is still protected by the protected call;
so, an error inside the message handler
will call the message handler again.
If this loop goes on for too long,
Lua breaks it and returns an appropriate message.
The message handler is called only for regular runtime errors.
It is not called for memory-allocation errors
nor for errors while running finalizers or other message handlers.
<p>
Lua also offers a system of <em>warnings</em> (see <a href="#pdf-warn"><code>warn</code></a>).
Unlike errors, warnings do not interfere
in any way with program execution.
They typically only generate a message to the user,
although this behavior can be adapted from C (see <a href="#lua_setwarnf"><code>lua_setwarnf</code></a>).
<h2>2.4 – <a name="2.4">Metatables and Metamethods</a></h2>
<p>
Every value in Lua can have a <em>metatable</em>.
This <em>metatable</em> is an ordinary Lua table
that defines the behavior of the original value
under certain events.
You can change several aspects of the behavior
of a value by setting specific fields in its metatable.
For instance, when a non-numeric value is the operand of an addition,
Lua checks for a function in the field <code>__add</code> of the value's metatable.
If it finds one,
Lua calls this function to perform the addition.
<p>
The key for each event in a metatable is a string
with the event name prefixed by two underscores;
the corresponding value is called a <em>metavalue</em>.
For most events, the metavalue must be a function,
which is then called a <em>metamethod</em>.
In the previous example, the key is the string "<code>__add</code>"
and the metamethod is the function that performs the addition.
Unless stated otherwise,
a metamethod may in fact be any callable value,
which is either a function or a value with a <code>__call</code> metamethod.
<p>
You can query the metatable of any value
using the <a href="#pdf-getmetatable"><code>getmetatable</code></a> function.
Lua queries metamethods in metatables using a raw access (see <a href="#pdf-rawget"><code>rawget</code></a>).
<p>
You can replace the metatable of tables
using the <a href="#pdf-setmetatable"><code>setmetatable</code></a> function.
You cannot change the metatable of other types from Lua code,
except by using the debug library (<a href="#6.10">§6.10</a>).
<p>
Tables and full userdata have individual metatables,
although multiple tables and userdata can share their metatables.
Values of all other types share one single metatable per type;
that is, there is one single metatable for all numbers,
one for all strings, etc.
By default, a value has no metatable,
but the string library sets a metatable for the string type (see <a href="#6.4">§6.4</a>).
<p>
A detailed list of operations controlled by metatables is given next.
Each event is identified by its corresponding key.
By convention, all metatable keys used by Lua are composed by
two underscores followed by lowercase Latin letters.
<ul>
<li><b><code>__add</code>: </b>
the addition (<code>+</code>) operation.
If any operand for an addition is not a number,
Lua will try to call a metamethod.
It starts by checking the first operand (even if it is a number);
if that operand does not define a metamethod for <code>__add</code>,
then Lua will check the second operand.
If Lua can find a metamethod,
it calls the metamethod with the two operands as arguments,
and the result of the call
(adjusted to one value)
is the result of the operation.
Otherwise, if no metamethod is found,
Lua raises an error.
</li>
<li><b><code>__sub</code>: </b>
the subtraction (<code>-</code>) operation.
Behavior similar to the addition operation.
</li>
<li><b><code>__mul</code>: </b>
the multiplication (<code>*</code>) operation.
Behavior similar to the addition operation.
</li>
<li><b><code>__div</code>: </b>
the division (<code>/</code>) operation.
Behavior similar to the addition operation.
</li>
<li><b><code>__mod</code>: </b>
the modulo (<code>%</code>) operation.
Behavior similar to the addition operation.
</li>
<li><b><code>__pow</code>: </b>
the exponentiation (<code>^</code>) operation.
Behavior similar to the addition operation.
</li>
<li><b><code>__unm</code>: </b>
the negation (unary <code>-</code>) operation.
Behavior similar to the addition operation.
</li>
<li><b><code>__idiv</code>: </b>
the floor division (<code>//</code>) operation.
Behavior similar to the addition operation.
</li>
<li><b><code>__band</code>: </b>
the bitwise AND (<code>&</code>) operation.
Behavior similar to the addition operation,
except that Lua will try a metamethod
if any operand is neither an integer
nor a float coercible to an integer (see <a href="#3.4.3">§3.4.3</a>).
</li>
<li><b><code>__bor</code>: </b>
the bitwise OR (<code>|</code>) operation.
Behavior similar to the bitwise AND operation.
</li>
<li><b><code>__bxor</code>: </b>
the bitwise exclusive OR (binary <code>~</code>) operation.
Behavior similar to the bitwise AND operation.
</li>
<li><b><code>__bnot</code>: </b>
the bitwise NOT (unary <code>~</code>) operation.
Behavior similar to the bitwise AND operation.
</li>
<li><b><code>__shl</code>: </b>
the bitwise left shift (<code><<</code>) operation.
Behavior similar to the bitwise AND operation.
</li>
<li><b><code>__shr</code>: </b>
the bitwise right shift (<code>>></code>) operation.
Behavior similar to the bitwise AND operation.
</li>
<li><b><code>__concat</code>: </b>
the concatenation (<code>..</code>) operation.
Behavior similar to the addition operation,
except that Lua will try a metamethod
if any operand is neither a string nor a number
(which is always coercible to a string).
</li>
<li><b><code>__len</code>: </b>
the length (<code>#</code>) operation.
If the object is not a string,
Lua will try its metamethod.
If there is a metamethod,
Lua calls it with the object as argument,
and the result of the call
(always adjusted to one value)
is the result of the operation.
If there is no metamethod but the object is a table,
then Lua uses the table length operation (see <a href="#3.4.7">§3.4.7</a>).
Otherwise, Lua raises an error.
</li>
<li><b><code>__eq</code>: </b>
the equal (<code>==</code>) operation.
Behavior similar to the addition operation,
except that Lua will try a metamethod only when the values
being compared are either both tables or both full userdata
and they are not primitively equal.
The result of the call is always converted to a boolean.
</li>
<li><b><code>__lt</code>: </b>
the less than (<code><</code>) operation.
Behavior similar to the addition operation,
except that Lua will try a metamethod only when the values
being compared are neither both numbers nor both strings.
Moreover, the result of the call is always converted to a boolean.
</li>
<li><b><code>__le</code>: </b>
the less equal (<code><=</code>) operation.
Behavior similar to the less than operation.
</li>
<li><b><code>__index</code>: </b>
The indexing access operation <code>table[key]</code>.
This event happens when <code>table</code> is not a table or
when <code>key</code> is not present in <code>table</code>.
The metavalue is looked up in the metatable of <code>table</code>.
<p>
The metavalue for this event can be either a function, a table,
or any value with an <code>__index</code> metavalue.
If it is a function,
it is called with <code>table</code> and <code>key</code> as arguments,
and the result of the call
(adjusted to one value)
is the result of the operation.
Otherwise,
the final result is the result of indexing this metavalue with <code>key</code>.
This indexing is regular, not raw,
and therefore can trigger another <code>__index</code> metavalue.
</li>
<li><b><code>__newindex</code>: </b>
The indexing assignment <code>table[key] = value</code>.
Like the index event,
this event happens when <code>table</code> is not a table or
when <code>key</code> is not present in <code>table</code>.
The metavalue is looked up in the metatable of <code>table</code>.
<p>
Like with indexing,
the metavalue for this event can be either a function, a table,
or any value with an <code>__newindex</code> metavalue.
If it is a function,
it is called with <code>table</code>, <code>key</code>, and <code>value</code> as arguments.
Otherwise,
Lua repeats the indexing assignment over this metavalue
with the same key and value.
This assignment is regular, not raw,
and therefore can trigger another <code>__newindex</code> metavalue.
<p>
Whenever a <code>__newindex</code> metavalue is invoked,
Lua does not perform the primitive assignment.
If needed,
the metamethod itself can call <a href="#pdf-rawset"><code>rawset</code></a>
to do the assignment.
</li>
<li><b><code>__call</code>: </b>
The call operation <code>func(args)</code>.
This event happens when Lua tries to call a non-function value
(that is, <code>func</code> is not a function).
The metamethod is looked up in <code>func</code>.
If present,
the metamethod is called with <code>func</code> as its first argument,
followed by the arguments of the original call (<code>args</code>).
All results of the call
are the results of the operation.
This is the only metamethod that allows multiple results.
</li>
</ul>
<p>
In addition to the previous list,
the interpreter also respects the following keys in metatables:
<code>__gc</code> (see <a href="#2.5.3">§2.5.3</a>),
<code>__close</code> (see <a href="#3.3.8">§3.3.8</a>),
<code>__mode</code> (see <a href="#2.5.4">§2.5.4</a>),
and <code>__name</code>.
(The entry <code>__name</code>,
when it contains a string,
may be used by <a href="#pdf-tostring"><code>tostring</code></a> and in error messages.)
<p>
For the unary operators (negation, length, and bitwise NOT),
the metamethod is computed and called with a dummy second operand,
equal to the first one.
This extra operand is only to simplify Lua's internals
(by making these operators behave like a binary operation)
and may be removed in future versions.
For most uses this extra operand is irrelevant.
<p>
Because metatables are regular tables,
they can contain arbitrary fields,
not only the event names defined above.
Some functions in the standard library
(e.g., <a href="#pdf-tostring"><code>tostring</code></a>)
use other fields in metatables for their own purposes.
<p>
It is a good practice to add all needed metamethods to a table
before setting it as a metatable of some object.
In particular, the <code>__gc</code> metamethod works only when this order
is followed (see <a href="#2.5.3">§2.5.3</a>).
It is also a good practice to set the metatable of an object
right after its creation.
<h2>2.5 – <a name="2.5">Garbage Collection</a></h2>
<p>
Lua performs automatic memory management.
This means that
you do not have to worry about allocating memory for new objects
or freeing it when the objects are no longer needed.
Lua manages memory automatically by running
a <em>garbage collector</em> to collect all <em>dead</em> objects.
All memory used by Lua is subject to automatic management:
strings, tables, userdata, functions, threads, internal structures, etc.
<p>
An object is considered <em>dead</em>
as soon as the collector can be sure the object
will not be accessed again in the normal execution of the program.
("Normal execution" here excludes finalizers,
which can resurrect dead objects (see <a href="#2.5.3">§2.5.3</a>),
and excludes also operations using the debug library.)
Note that the time when the collector can be sure that an object
is dead may not coincide with the programmer's expectations.
The only guarantees are that Lua will not collect an object
that may still be accessed in the normal execution of the program,
and it will eventually collect an object
that is inaccessible from Lua.
(Here,
<em>inaccessible from Lua</em> means that neither a variable nor
another live object refer to the object.)
Because Lua has no knowledge about C code,
it never collects objects accessible through the registry (see <a href="#4.3">§4.3</a>),
which includes the global environment (see <a href="#2.2">§2.2</a>).
<p>
The garbage collector (GC) in Lua can work in two modes:
incremental and generational.
<p>
The default GC mode with the default parameters
are adequate for most uses.
However, programs that waste a large proportion of their time
allocating and freeing memory can benefit from other settings.
Keep in mind that the GC behavior is non-portable
both across platforms and across different Lua releases;
therefore, optimal settings are also non-portable.
<p>
You can change the GC mode and parameters by calling
<a href="#lua_gc"><code>lua_gc</code></a> in C
or <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> in Lua.
You can also use these functions to control
the collector directly (e.g., to stop and restart it).
<h3>2.5.1 – <a name="2.5.1">Incremental Garbage Collection</a></h3>
<p>
In incremental mode,
each GC cycle performs a mark-and-sweep collection in small steps
interleaved with the program's execution.
In this mode,
the collector uses three numbers to control its garbage-collection cycles:
the <em>garbage-collector pause</em>,
the <em>garbage-collector step multiplier</em>,
and the <em>garbage-collector step size</em>.
<p>
The garbage-collector pause
controls how long the collector waits before starting a new cycle.
The collector starts a new cycle when the use of memory
hits <em>n%</em> of the use after the previous collection.
Larger values make the collector less aggressive.
Values equal to or less than 100 mean the collector will not wait to
start a new cycle.
A value of 200 means that the collector waits for the total memory in use
to double before starting a new cycle.
The default value is 200; the maximum value is 1000.
<p>
The garbage-collector step multiplier
controls the speed of the collector relative to
memory allocation,
that is,
how many elements it marks or sweeps for each
kilobyte of memory allocated.
Larger values make the collector more aggressive but also increase
the size of each incremental step.
You should not use values less than 100,
because they make the collector too slow and
can result in the collector never finishing a cycle.
The default value is 100; the maximum value is 1000.
<p>
The garbage-collector step size controls the
size of each incremental step,
specifically how many bytes the interpreter allocates
before performing a step.
This parameter is logarithmic:
A value of <em>n</em> means the interpreter will allocate <em>2<sup>n</sup></em>
bytes between steps and perform equivalent work during the step.
A large value (e.g., 60) makes the collector a stop-the-world
(non-incremental) collector.
The default value is 13,
which means steps of approximately 8 Kbytes.
<h3>2.5.2 – <a name="2.5.2">Generational Garbage Collection</a></h3>
<p>
In generational mode,
the collector does frequent <em>minor</em> collections,
which traverses only objects recently created.
If after a minor collection the use of memory is still above a limit,
the collector does a stop-the-world <em>major</em> collection,
which traverses all objects.
The generational mode uses two parameters:
the <em>minor multiplier</em> and the <em>the major multiplier</em>.
<p>
The minor multiplier controls the frequency of minor collections.
For a minor multiplier <em>x</em>,
a new minor collection will be done when memory
grows <em>x%</em> larger than the memory in use after the previous major
collection.
For instance, for a multiplier of 20,
the collector will do a minor collection when the use of memory
gets 20% larger than the use after the previous major collection.
The default value is 20; the maximum value is 200.
<p>
The major multiplier controls the frequency of major collections.
For a major multiplier <em>x</em>,
a new major collection will be done when memory
grows <em>x%</em> larger than the memory in use after the previous major
collection.
For instance, for a multiplier of 100,
the collector will do a major collection when the use of memory
gets larger than twice the use after the previous collection.
The default value is 100; the maximum value is 1000.
<h3>2.5.3 – <a name="2.5.3">Garbage-Collection Metamethods</a></h3>
<p>
You can set garbage-collector metamethods for tables
and, using the C API,
for full userdata (see <a href="#2.4">§2.4</a>).
These metamethods, called <em>finalizers</em>,
are called when the garbage collector detects that the
corresponding table or userdata is dead.
Finalizers allow you to coordinate Lua's garbage collection
with external resource management such as closing files,
network or database connections,
or freeing your own memory.
<p>
For an object (table or userdata) to be finalized when collected,
you must <em>mark</em> it for finalization.
You mark an object for finalization when you set its metatable
and the metatable has a <code>__gc</code> metamethod.
Note that if you set a metatable without a <code>__gc</code> field
and later create that field in the metatable,
the object will not be marked for finalization.
<p>
When a marked object becomes dead,
it is not collected immediately by the garbage collector.
Instead, Lua puts it in a list.
After the collection,
Lua goes through that list.
For each object in the list,
it checks the object's <code>__gc</code> metamethod:
If it is present,
Lua calls it with the object as its single argument.
<p>
At the end of each garbage-collection cycle,
the finalizers are called in
the reverse order that the objects were marked for finalization,
among those collected in that cycle;
that is, the first finalizer to be called is the one associated
with the object marked last in the program.
The execution of each finalizer may occur at any point during
the execution of the regular code.
<p>
Because the object being collected must still be used by the finalizer,
that object (and other objects accessible only through it)
must be <em>resurrected</em> by Lua.
Usually, this resurrection is transient,
and the object memory is freed in the next garbage-collection cycle.
However, if the finalizer stores the object in some global place
(e.g., a global variable),
then the resurrection is permanent.
Moreover, if the finalizer marks a finalizing object for finalization again,
its finalizer will be called again in the next cycle where the
object is dead.
In any case,
the object memory is freed only in a GC cycle where
the object is dead and not marked for finalization.
<p>
When you close a state (see <a href="#lua_close"><code>lua_close</code></a>),
Lua calls the finalizers of all objects marked for finalization,
following the reverse order that they were marked.
If any finalizer marks objects for collection during that phase,
these marks have no effect.
<p>
Finalizers cannot yield.
Except for that, they can do anything,
such as raise errors, create new objects,
or even run the garbage collector.
However, because they can run in unpredictable times,
it is good practice to restrict each finalizer
to the minimum necessary to properly release
its associated resource.
<p>
Any error while running a finalizer generates a warning;
the error is not propagated.
<h3>2.5.4 – <a name="2.5.4">Weak Tables</a></h3>
<p>
A <em>weak table</em> is a table whose elements are
<em>weak references</em>.
A weak reference is ignored by the garbage collector.
In other words,
if the only references to an object are weak references,
then the garbage collector will collect that object.
<p>
A weak table can have weak keys, weak values, or both.
A table with weak values allows the collection of its values,
but prevents the collection of its keys.
A table with both weak keys and weak values allows the collection of
both keys and values.
In any case, if either the key or the value is collected,
the whole pair is removed from the table.
The weakness of a table is controlled by the
<code>__mode</code> field of its metatable.
This metavalue, if present, must be one of the following strings:
"<code>k</code>", for a table with weak keys;
"<code>v</code>", for a table with weak values;
or "<code>kv</code>", for a table with both weak keys and values.
<p>
A table with weak keys and strong values
is also called an <em>ephemeron table</em>.
In an ephemeron table,
a value is considered reachable only if its key is reachable.
In particular,
if the only reference to a key comes through its value,
the pair is removed.
<p>
Any change in the weakness of a table may take effect only
at the next collect cycle.
In particular, if you change the weakness to a stronger mode,
Lua may still collect some items from that table
before the change takes effect.
<p>
Only objects that have an explicit construction
are removed from weak tables.
Values, such as numbers and light C functions,
are not subject to garbage collection,
and therefore are not removed from weak tables
(unless their associated values are collected).
Although strings are subject to garbage collection,
they do not have an explicit construction and
their equality is by value;
they behave more like values than like objects.
Therefore, they are not removed from weak tables.
<p>
Resurrected objects
(that is, objects being finalized
and objects accessible only through objects being finalized)
have a special behavior in weak tables.
They are removed from weak values before running their finalizers,
but are removed from weak keys only in the next collection
after running their finalizers, when such objects are actually freed.
This behavior allows the finalizer to access properties
associated with the object through weak tables.
<p>
If a weak table is among the resurrected objects in a collection cycle,
it may not be properly cleared until the next cycle.
<h2>2.6 – <a name="2.6">Coroutines</a></h2>
<p>
Lua supports coroutines,
also called <em>collaborative multithreading</em>.
A coroutine in Lua represents an independent thread of execution.
Unlike threads in multithread systems, however,
a coroutine only suspends its execution by explicitly calling
a yield function.
<p>
You create a coroutine by calling <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>.
Its sole argument is a function
that is the main function of the coroutine.
The <code>create</code> function only creates a new coroutine and
returns a handle to it (an object of type <em>thread</em>);
it does not start the coroutine.
<p>
You execute a coroutine by calling <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
When you first call <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
passing as its first argument
a thread returned by <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
the coroutine starts its execution by
calling its main function.
Extra arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> are passed
as arguments to that function.
After the coroutine starts running,
it runs until it terminates or <em>yields</em>.
<p>
A coroutine can terminate its execution in two ways:
normally, when its main function returns
(explicitly or implicitly, after the last instruction);
and abnormally, if there is an unprotected error.
In case of normal termination,
<a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>true</b>,
plus any values returned by the coroutine main function.
In case of errors, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>false</b>
plus the error object.
In this case, the coroutine does not unwind its stack,
so that it is possible to inspect it after the error
with the debug API.
<p>
A coroutine yields by calling <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
When a coroutine yields,
the corresponding <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns immediately,
even if the yield happens inside nested function calls
(that is, not in the main function,
but in a function directly or indirectly called by the main function).
In the case of a yield, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> also returns <b>true</b>,
plus any values passed to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
The next time you resume the same coroutine,
it continues its execution from the point where it yielded,
with the call to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a> returning any extra
arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
<p>
Like <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
the <a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> function also creates a coroutine,
but instead of returning the coroutine itself,
it returns a function that, when called, resumes the coroutine.
Any arguments passed to this function
go as extra arguments to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> returns all the values returned by <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
except the first one (the boolean error code).
Unlike <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
the function created by <a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a>
propagates any error to the caller.
In this case,
the function also closes the coroutine (see <a href="#pdf-coroutine.close"><code>coroutine.close</code></a>).
<p>
As an example of how coroutines work,
consider the following code:
<pre>
function foo (a)
print("foo", a)
return coroutine.yield(2*a)
end
co = coroutine.create(function (a,b)
print("co-body", a, b)
local r = foo(a+1)
print("co-body", r)
local r, s = coroutine.yield(a+b, a-b)
print("co-body", r, s)
return b, "end"
end)
print("main", coroutine.resume(co, 1, 10))
print("main", coroutine.resume(co, "r"))
print("main", coroutine.resume(co, "x", "y"))
print("main", coroutine.resume(co, "x", "y"))
</pre><p>
When you run it, it produces the following output:
<pre>
co-body 1 10
foo 2
main true 4
co-body r
main true 11 -9
co-body x y
main true 10 end
main false cannot resume dead coroutine
</pre>
<p>
You can also create and manipulate coroutines through the C API:
see functions <a href="#lua_newthread"><code>lua_newthread</code></a>, <a href="#lua_resume"><code>lua_resume</code></a>,
and <a href="#lua_yield"><code>lua_yield</code></a>.
<h1>3 – <a name="3">The Language</a></h1>
<p>
This section describes the lexis, the syntax, and the semantics of Lua.
In other words,
this section describes
which tokens are valid,
how they can be combined,
and what their combinations mean.
<p>
Language constructs will be explained using the usual extended BNF notation,
in which
{<em>a</em>} means 0 or more <em>a</em>'s, and
[<em>a</em>] means an optional <em>a</em>.
Non-terminals are shown like non-terminal,
keywords are shown like <b>kword</b>,
and other terminal symbols are shown like ‘<b>=</b>’.
The complete syntax of Lua can be found in <a href="#9">§9</a>
at the end of this manual.
<h2>3.1 – <a name="3.1">Lexical Conventions</a></h2>
<p>
Lua is a free-form language.
It ignores spaces and comments between lexical elements (tokens),
except as delimiters between two tokens.
In source code,
Lua recognizes as spaces the standard ASCII whitespace
characters space, form feed, newline,
carriage return, horizontal tab, and vertical tab.
<p>
<em>Names</em>
(also called <em>identifiers</em>)
in Lua can be any string of Latin letters,
Arabic-Indic digits, and underscores,
not beginning with a digit and
not being a reserved word.
Identifiers are used to name variables, table fields, and labels.
<p>
The following <em>keywords</em> are reserved
and cannot be used as names:
<pre>
and break do else elseif end
false for function goto if in
local nil not or repeat return
then true until while
</pre>
<p>
Lua is a case-sensitive language:
<code>and</code> is a reserved word, but <code>And</code> and <code>AND</code>
are two different, valid names.
As a convention,
programs should avoid creating
names that start with an underscore followed by
one or more uppercase letters (such as <a href="#pdf-_VERSION"><code>_VERSION</code></a>).
<p>
The following strings denote other tokens:
<pre>
+ - * / % ^ #
& ~ | << >> //
== ~= <= >= < > =
( ) { } [ ] ::
; : , . .. ...
</pre>
<p>
A <em>short literal string</em>
can be delimited by matching single or double quotes,
and can contain the following C-like escape sequences:
'<code>\a</code>' (bell),
'<code>\b</code>' (backspace),
'<code>\f</code>' (form feed),
'<code>\n</code>' (newline),
'<code>\r</code>' (carriage return),
'<code>\t</code>' (horizontal tab),
'<code>\v</code>' (vertical tab),
'<code>\\</code>' (backslash),
'<code>\"</code>' (quotation mark [double quote]),
and '<code>\'</code>' (apostrophe [single quote]).
A backslash followed by a line break
results in a newline in the string.
The escape sequence '<code>\z</code>' skips the following span
of whitespace characters,
including line breaks;
it is particularly useful to break and indent a long literal string
into multiple lines without adding the newlines and spaces
into the string contents.
A short literal string cannot contain unescaped line breaks
nor escapes not forming a valid escape sequence.
<p>
We can specify any byte in a short literal string,
including embedded zeros,
by its numeric value.
This can be done
with the escape sequence <code>\x<em>XX</em></code>,
where <em>XX</em> is a sequence of exactly two hexadecimal digits,
or with the escape sequence <code>\<em>ddd</em></code>,
where <em>ddd</em> is a sequence of up to three decimal digits.
(Note that if a decimal escape sequence is to be followed by a digit,
it must be expressed using exactly three digits.)
<p>
The UTF-8 encoding of a Unicode character
can be inserted in a literal string with
the escape sequence <code>\u{<em>XXX</em>}</code>
(with mandatory enclosing braces),
where <em>XXX</em> is a sequence of one or more hexadecimal digits
representing the character code point.
This code point can be any value less than <em>2<sup>31</sup></em>.
(Lua uses the original UTF-8 specification here,
which is not restricted to valid Unicode code points.)
<p>
Literal strings can also be defined using a long format
enclosed by <em>long brackets</em>.
We define an <em>opening long bracket of level <em>n</em></em> as an opening
square bracket followed by <em>n</em> equal signs followed by another
opening square bracket.
So, an opening long bracket of level 0 is written as <code>[[</code>,
an opening long bracket of level 1 is written as <code>[=[</code>,
and so on.
A <em>closing long bracket</em> is defined similarly;
for instance,
a closing long bracket of level 4 is written as <code>]====]</code>.
A <em>long literal</em> starts with an opening long bracket of any level and
ends at the first closing long bracket of the same level.
It can contain any text except a closing bracket of the same level.
Literals in this bracketed form can run for several lines,
do not interpret any escape sequences,
and ignore long brackets of any other level.
Any kind of end-of-line sequence
(carriage return, newline, carriage return followed by newline,
or newline followed by carriage return)
is converted to a simple newline.
When the opening long bracket is immediately followed by a newline,
the newline is not included in the string.
<p>
As an example, in a system using ASCII
(in which '<code>a</code>' is coded as 97,
newline is coded as 10, and '<code>1</code>' is coded as 49),
the five literal strings below denote the same string:
<pre>
a = 'alo\n123"'
a = "alo\n123\""
a = '\97lo\10\04923"'
a = [[alo
123"]]
a = [==[
alo
123"]==]
</pre>
<p>
Any byte in a literal string not
explicitly affected by the previous rules represents itself.
However, Lua opens files for parsing in text mode,
and the system's file functions may have problems with
some control characters.
So, it is safer to represent
binary data as a quoted literal with
explicit escape sequences for the non-text characters.
<p>
A <em>numeric constant</em> (or <em>numeral</em>)
can be written with an optional fractional part
and an optional decimal exponent,
marked by a letter '<code>e</code>' or '<code>E</code>'.
Lua also accepts hexadecimal constants,
which start with <code>0x</code> or <code>0X</code>.
Hexadecimal constants also accept an optional fractional part
plus an optional binary exponent,
marked by a letter '<code>p</code>' or '<code>P</code>'.
<p>
A numeric constant with a radix point or an exponent
denotes a float;
otherwise,
if its value fits in an integer or it is a hexadecimal constant,
it denotes an integer;
otherwise (that is, a decimal integer numeral that overflows),
it denotes a float.
Hexadecimal numerals with neither a radix point nor an exponent
always denote an integer value;
if the value overflows, it <em>wraps around</em>
to fit into a valid integer.
<p>
Examples of valid integer constants are
<pre>
3 345 0xff 0xBEBADA
</pre><p>
Examples of valid float constants are
<pre>
3.0 3.1416 314.16e-2 0.31416E1 34e1
0x0.1E 0xA23p-4 0X1.921FB54442D18P+1
</pre>
<p>
A <em>comment</em> starts with a double hyphen (<code>--</code>)
anywhere outside a string.
If the text immediately after <code>--</code> is not an opening long bracket,
the comment is a <em>short comment</em>,
which runs until the end of the line.
Otherwise, it is a <em>long comment</em>,
which runs until the corresponding closing long bracket.
<h2>3.2 – <a name="3.2">Variables</a></h2>
<p>
Variables are places that store values.
There are three kinds of variables in Lua:
global variables, local variables, and table fields.
<p>
A single name can denote a global variable or a local variable
(or a function's formal parameter,
which is a particular kind of local variable):
<pre>
var ::= Name
</pre><p>
Name denotes identifiers (see <a href="#3.1">§3.1</a>).
<p>
Any variable name is assumed to be global unless explicitly declared
as a local (see <a href="#3.3.7">§3.3.7</a>).
Local variables are <em>lexically scoped</em>:
local variables can be freely accessed by functions
defined inside their scope (see <a href="#3.5">§3.5</a>).
<p>
Before the first assignment to a variable, its value is <b>nil</b>.
<p>
Square brackets are used to index a table:
<pre>
var ::= prefixexp ‘<b>[</b>’ exp ‘<b>]</b>’
</pre><p>
The meaning of accesses to table fields can be changed via metatables
(see <a href="#2.4">§2.4</a>).
<p>
The syntax <code>var.Name</code> is just syntactic sugar for
<code>var["Name"]</code>:
<pre>
var ::= prefixexp ‘<b>.</b>’ Name
</pre>
<p>
An access to a global variable <code>x</code>
is equivalent to <code>_ENV.x</code>.
Due to the way that chunks are compiled,
the variable <code>_ENV</code> itself is never global (see <a href="#2.2">§2.2</a>).
<h2>3.3 – <a name="3.3">Statements</a></h2>
<p>
Lua supports an almost conventional set of statements,
similar to those in other conventional languages.
This set includes
blocks, assignments, control structures, function calls,
and variable declarations.
<h3>3.3.1 – <a name="3.3.1">Blocks</a></h3>
<p>
A block is a list of statements,
which are executed sequentially:
<pre>
block ::= {stat}
</pre><p>
Lua has <em>empty statements</em>
that allow you to separate statements with semicolons,
start a block with a semicolon
or write two semicolons in sequence:
<pre>
stat ::= ‘<b>;</b>’
</pre>
<p>
Both function calls and assignments
can start with an open parenthesis.
This possibility leads to an ambiguity in Lua's grammar.
Consider the following fragment:
<pre>
a = b + c
(print or io.write)('done')
</pre><p>
The grammar could see this fragment in two ways:
<pre>
a = b + c(print or io.write)('done')
a = b + c; (print or io.write)('done')
</pre><p>
The current parser always sees such constructions
in the first way,
interpreting the open parenthesis
as the start of the arguments to a call.
To avoid this ambiguity,
it is a good practice to always precede with a semicolon
statements that start with a parenthesis:
<pre>
;(print or io.write)('done')
</pre>
<p>
A block can be explicitly delimited to produce a single statement:
<pre>
stat ::= <b>do</b> block <b>end</b>
</pre><p>
Explicit blocks are useful
to control the scope of variable declarations.
Explicit blocks are also sometimes used to
add a <b>return</b> statement in the middle
of another block (see <a href="#3.3.4">§3.3.4</a>).
<h3>3.3.2 – <a name="3.3.2">Chunks</a></h3>
<p>
The unit of compilation of Lua is called a <em>chunk</em>.
Syntactically,
a chunk is simply a block:
<pre>
chunk ::= block
</pre>
<p>
Lua handles a chunk as the body of an anonymous function
with a variable number of arguments
(see <a href="#3.4.11">§3.4.11</a>).
As such, chunks can define local variables,
receive arguments, and return values.
Moreover, such anonymous function is compiled as in the
scope of an external local variable called <code>_ENV</code> (see <a href="#2.2">§2.2</a>).
The resulting function always has <code>_ENV</code> as its only external variable,
even if it does not use that variable.
<p>
A chunk can be stored in a file or in a string inside the host program.
To execute a chunk,
Lua first <em>loads</em> it,
precompiling the chunk's code into instructions for a virtual machine,
and then Lua executes the compiled code
with an interpreter for the virtual machine.
<p>
Chunks can also be precompiled into binary form;
see the program <code>luac</code> and the function <a href="#pdf-string.dump"><code>string.dump</code></a> for details.
Programs in source and compiled forms are interchangeable;
Lua automatically detects the file type and acts accordingly (see <a href="#pdf-load"><code>load</code></a>).
<h3>3.3.3 – <a name="3.3.3">Assignment</a></h3>
<p>
Lua allows multiple assignments.
Therefore, the syntax for assignment
defines a list of variables on the left side
and a list of expressions on the right side.
The elements in both lists are separated by commas:
<pre>
stat ::= varlist ‘<b>=</b>’ explist
varlist ::= var {‘<b>,</b>’ var}
explist ::= exp {‘<b>,</b>’ exp}
</pre><p>
Expressions are discussed in <a href="#3.4">§3.4</a>.
<p>
Before the assignment,
the list of values is <em>adjusted</em> to the length of
the list of variables.
If there are more values than needed,
the excess values are thrown away.
If there are fewer values than needed,
the list is extended with <b>nil</b>'s.
If the list of expressions ends with a function call,
then all values returned by that call enter the list of values,
before the adjustment
(except when the call is enclosed in parentheses; see <a href="#3.4">§3.4</a>).
<p>
The assignment statement first evaluates all its expressions
and only then the assignments are performed.
Thus the code
<pre>
i = 3
i, a[i] = i+1, 20
</pre><p>
sets <code>a[3]</code> to 20, without affecting <code>a[4]</code>
because the <code>i</code> in <code>a[i]</code> is evaluated (to 3)
before it is assigned 4.
Similarly, the line
<pre>
x, y = y, x
</pre><p>
exchanges the values of <code>x</code> and <code>y</code>,
and
<pre>
x, y, z = y, z, x
</pre><p>
cyclically permutes the values of <code>x</code>, <code>y</code>, and <code>z</code>.
<p>
An assignment to a global name <code>x = val</code>
is equivalent to the assignment
<code>_ENV.x = val</code> (see <a href="#2.2">§2.2</a>).
<p>
The meaning of assignments to table fields and
global variables (which are actually table fields, too)
can be changed via metatables (see <a href="#2.4">§2.4</a>).
<h3>3.3.4 – <a name="3.3.4">Control Structures</a></h3><p>
The control structures
<b>if</b>, <b>while</b>, and <b>repeat</b> have the usual meaning and
familiar syntax:
<pre>
stat ::= <b>while</b> exp <b>do</b> block <b>end</b>
stat ::= <b>repeat</b> block <b>until</b> exp
stat ::= <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b>
</pre><p>
Lua also has a <b>for</b> statement, in two flavors (see <a href="#3.3.5">§3.3.5</a>).
<p>
The condition expression of a
control structure can return any value.
Both <b>false</b> and <b>nil</b> test false.
All values different from <b>nil</b> and <b>false</b> test true.
In particular, the number 0 and the empty string also test true.
<p>
In the <b>repeat</b>–<b>until</b> loop,
the inner block does not end at the <b>until</b> keyword,
but only after the condition.
So, the condition can refer to local variables
declared inside the loop block.
<p>
The <b>goto</b> statement transfers the program control to a label.
For syntactical reasons,
labels in Lua are considered statements too:
<pre>
stat ::= <b>goto</b> Name
stat ::= label
label ::= ‘<b>::</b>’ Name ‘<b>::</b>’
</pre>
<p>
A label is visible in the entire block where it is defined,
except inside nested functions.
A goto may jump to any visible label as long as it does not
enter into the scope of a local variable.
A label should not be declared
where a label with the same name is visible,
even if this other label has been declared in an enclosing block.
<p>
Labels and empty statements are called <em>void statements</em>,
as they perform no actions.
<p>
The <b>break</b> statement terminates the execution of a
<b>while</b>, <b>repeat</b>, or <b>for</b> loop,
skipping to the next statement after the loop:
<pre>
stat ::= <b>break</b>
</pre><p>
A <b>break</b> ends the innermost enclosing loop.
<p>
The <b>return</b> statement is used to return values
from a function or a chunk
(which is handled as an anonymous function).
Functions can return more than one value,
so the syntax for the <b>return</b> statement is
<pre>
stat ::= <b>return</b> [explist] [‘<b>;</b>’]
</pre>
<p>
The <b>return</b> statement can only be written
as the last statement of a block.
If it is necessary to <b>return</b> in the middle of a block,
then an explicit inner block can be used,
as in the idiom <code>do return end</code>,
because now <b>return</b> is the last statement in its (inner) block.
<h3>3.3.5 – <a name="3.3.5">For Statement</a></h3>
<p>
The <b>for</b> statement has two forms:
one numerical and one generic.
<h4>The numerical <b>for</b> loop</h4>
<p>
The numerical <b>for</b> loop repeats a block of code while a
control variable goes through an arithmetic progression.
It has the following syntax:
<pre>
stat ::= <b>for</b> Name ‘<b>=</b>’ exp ‘<b>,</b>’ exp [‘<b>,</b>’ exp] <b>do</b> block <b>end</b>
</pre><p>
The given identifier (Name) defines the control variable,
which is a new variable local to the loop body (<em>block</em>).
<p>
The loop starts by evaluating once the three control expressions.
Their values are called respectively
the <em>initial value</em>, the <em>limit</em>, and the <em>step</em>.
If the step is absent, it defaults to 1.
<p>
If both the initial value and the step are integers,
the loop is done with integers;
note that the limit may not be an integer.
Otherwise, the three values are converted to
floats and the loop is done with floats.
Beware of floating-point accuracy in this case.
<p>
After that initialization,
the loop body is repeated with the value of the control variable
going through an arithmetic progression,
starting at the initial value,
with a common difference given by the step.
A negative step makes a decreasing sequence;
a step equal to zero raises an error.
The loop continues while the value is less than
or equal to the limit
(greater than or equal to for a negative step).
If the initial value is already greater than the limit
(or less than, if the step is negative),
the body is not executed.
<p>
For integer loops,
the control variable never wraps around;
instead, the loop ends in case of an overflow.
<p>
You should not change the value of the control variable
during the loop.
If you need its value after the loop,
assign it to another variable before exiting the loop.
<h4>The generic <b>for</b> loop</h4>
<p>
The generic <b>for</b> statement works over functions,
called <em>iterators</em>.
On each iteration, the iterator function is called to produce a new value,
stopping when this new value is <b>nil</b>.
The generic <b>for</b> loop has the following syntax:
<pre>
stat ::= <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b>
namelist ::= Name {‘<b>,</b>’ Name}
</pre><p>
A <b>for</b> statement like
<pre>
for <em>var_1</em>, ···, <em>var_n</em> in <em>explist</em> do <em>body</em> end
</pre><p>
works as follows.
<p>
The names <em>var_i</em> declare loop variables local to the loop body.
The first of these variables is the <em>control variable</em>.
<p>
The loop starts by evaluating <em>explist</em>
to produce four values:
an <em>iterator function</em>,
a <em>state</em>,
an initial value for the control variable,
and a <em>closing value</em>.
<p>
Then, at each iteration,
Lua calls the iterator function with two arguments:
the state and the control variable.
The results from this call are then assigned to the loop variables,
following the rules of multiple assignments (see <a href="#3.3.3">§3.3.3</a>).
If the control variable becomes <b>nil</b>,
the loop terminates.
Otherwise, the body is executed and the loop goes
to the next iteration.
<p>
The closing value behaves like a
to-be-closed variable (see <a href="#3.3.8">§3.3.8</a>),
which can be used to release resources when the loop ends.
Otherwise, it does not interfere with the loop.
<p>
You should not change the value of the control variable
during the loop.
<h3>3.3.6 – <a name="3.3.6">Function Calls as Statements</a></h3><p>
To allow possible side-effects,
function calls can be executed as statements:
<pre>
stat ::= functioncall
</pre><p>
In this case, all returned values are thrown away.
Function calls are explained in <a href="#3.4.10">§3.4.10</a>.
<h3>3.3.7 – <a name="3.3.7">Local Declarations</a></h3><p>
Local variables can be declared anywhere inside a block.
The declaration can include an initialization:
<pre>
stat ::= <b>local</b> attnamelist [‘<b>=</b>’ explist]
attnamelist ::= Name attrib {‘<b>,</b>’ Name attrib}
</pre><p>
If present, an initial assignment has the same semantics
of a multiple assignment (see <a href="#3.3.3">§3.3.3</a>).
Otherwise, all variables are initialized with <b>nil</b>.
<p>
Each variable name may be postfixed by an attribute
(a name between angle brackets):
<pre>
attrib ::= [‘<b><</b>’ Name ‘<b>></b>’]
</pre><p>
There are two possible attributes:
<code>const</code>, which declares a constant variable,
that is, a variable that cannot be assigned to
after its initialization;
and <code>close</code>, which declares a to-be-closed variable (see <a href="#3.3.8">§3.3.8</a>).
A list of variables can contain at most one to-be-closed variable.
<p>
A chunk is also a block (see <a href="#3.3.2">§3.3.2</a>),
and so local variables can be declared in a chunk outside any explicit block.
<p>
The visibility rules for local variables are explained in <a href="#3.5">§3.5</a>.
<h3>3.3.8 – <a name="3.3.8">To-be-closed Variables</a></h3>
<p>
A to-be-closed variable behaves like a constant local variable,
except that its value is <em>closed</em> whenever the variable
goes out of scope, including normal block termination,
exiting its block by <b>break</b>/<b>goto</b>/<b>return</b>,
or exiting by an error.
<p>
Here, to <em>close</em> a value means
to call its <code>__close</code> metamethod.
When calling the metamethod,
the value itself is passed as the first argument
and the error object that caused the exit (if any)
is passed as a second argument;
if there was no error, the second argument is <b>nil</b>.
<p>
The value assigned to a to-be-closed variable
must have a <code>__close</code> metamethod
or be a false value.
(<b>nil</b> and <b>false</b> are ignored as to-be-closed values.)
<p>
If several to-be-closed variables go out of scope at the same event,
they are closed in the reverse order that they were declared.
<p>
If there is any error while running a closing method,
that error is handled like an error in the regular code
where the variable was defined.
After an error,
the other pending closing methods will still be called.
<p>
If a coroutine yields and is never resumed again,
some variables may never go out of scope,
and therefore they will never be closed.
(These variables are the ones created inside the coroutine
and in scope at the point where the coroutine yielded.)
Similarly, if a coroutine ends with an error,
it does not unwind its stack,
so it does not close any variable.
In both cases,
you can either use finalizers
or call <a href="#pdf-coroutine.close"><code>coroutine.close</code></a> to close the variables.
However, if the coroutine was created
through <a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a>,
then its corresponding function will close the coroutine
in case of errors.
<h2>3.4 – <a name="3.4">Expressions</a></h2>
<p>
The basic expressions in Lua are the following:
<pre>
exp ::= prefixexp
exp ::= <b>nil</b> | <b>false</b> | <b>true</b>
exp ::= Numeral
exp ::= LiteralString
exp ::= functiondef
exp ::= tableconstructor
exp ::= ‘<b>...</b>’
exp ::= exp binop exp
exp ::= unop exp
prefixexp ::= var | functioncall | ‘<b>(</b>’ exp ‘<b>)</b>’
</pre>
<p>
Numerals and literal strings are explained in <a href="#3.1">§3.1</a>;
variables are explained in <a href="#3.2">§3.2</a>;
function definitions are explained in <a href="#3.4.11">§3.4.11</a>;
function calls are explained in <a href="#3.4.10">§3.4.10</a>;
table constructors are explained in <a href="#3.4.9">§3.4.9</a>.
Vararg expressions,
denoted by three dots ('<code>...</code>'), can only be used when
directly inside a vararg function;
they are explained in <a href="#3.4.11">§3.4.11</a>.
<p>
Binary operators comprise arithmetic operators (see <a href="#3.4.1">§3.4.1</a>),
bitwise operators (see <a href="#3.4.2">§3.4.2</a>),
relational operators (see <a href="#3.4.4">§3.4.4</a>), logical operators (see <a href="#3.4.5">§3.4.5</a>),
and the concatenation operator (see <a href="#3.4.6">§3.4.6</a>).
Unary operators comprise the unary minus (see <a href="#3.4.1">§3.4.1</a>),
the unary bitwise NOT (see <a href="#3.4.2">§3.4.2</a>),
the unary logical <b>not</b> (see <a href="#3.4.5">§3.4.5</a>),
and the unary <em>length operator</em> (see <a href="#3.4.7">§3.4.7</a>).
<p>
Both function calls and vararg expressions can result in multiple values.
If a function call is used as a statement (see <a href="#3.3.6">§3.3.6</a>),
then its return list is adjusted to zero elements,
thus discarding all returned values.
If an expression is used as the last (or the only) element
of a list of expressions,
then no adjustment is made
(unless the expression is enclosed in parentheses).
In all other contexts,
Lua adjusts the result list to one element,
either discarding all values except the first one
or adding a single <b>nil</b> if there are no values.
<p>
Here are some examples:
<pre>
f() -- adjusted to 0 results
g(f(), x) -- f() is adjusted to 1 result
g(x, f()) -- g gets x plus all results from f()
a,b,c = f(), x -- f() is adjusted to 1 result (c gets nil)
a,b = ... -- a gets the first vararg argument, b gets
-- the second (both a and b can get nil if there
-- is no corresponding vararg argument)
a,b,c = x, f() -- f() is adjusted to 2 results
a,b,c = f() -- f() is adjusted to 3 results
return f() -- returns all results from f()
return ... -- returns all received vararg arguments
return x,y,f() -- returns x, y, and all results from f()
{f()} -- creates a list with all results from f()
{...} -- creates a list with all vararg arguments
{f(), nil} -- f() is adjusted to 1 result
</pre>
<p>
Any expression enclosed in parentheses always results in only one value.
Thus,
<code>(f(x,y,z))</code> is always a single value,
even if <code>f</code> returns several values.
(The value of <code>(f(x,y,z))</code> is the first value returned by <code>f</code>
or <b>nil</b> if <code>f</code> does not return any values.)
<h3>3.4.1 – <a name="3.4.1">Arithmetic Operators</a></h3><p>
Lua supports the following arithmetic operators:
<ul>
<li><b><code>+</code>: </b>addition</li>
<li><b><code>-</code>: </b>subtraction</li>
<li><b><code>*</code>: </b>multiplication</li>
<li><b><code>/</code>: </b>float division</li>
<li><b><code>//</code>: </b>floor division</li>
<li><b><code>%</code>: </b>modulo</li>
<li><b><code>^</code>: </b>exponentiation</li>
<li><b><code>-</code>: </b>unary minus</li>
</ul>
<p>
With the exception of exponentiation and float division,
the arithmetic operators work as follows:
If both operands are integers,
the operation is performed over integers and the result is an integer.
Otherwise, if both operands are numbers,
then they are converted to floats,
the operation is performed following the machine's rules
for floating-point arithmetic
(usually the IEEE 754 standard),
and the result is a float.
(The string library coerces strings to numbers in
arithmetic operations; see <a href="#3.4.3">§3.4.3</a> for details.)
<p>
Exponentiation and float division (<code>/</code>)
always convert their operands to floats
and the result is always a float.
Exponentiation uses the ISO C function <code>pow</code>,
so that it works for non-integer exponents too.
<p>
Floor division (<code>//</code>) is a division
that rounds the quotient towards minus infinity,
resulting in the floor of the division of its operands.
<p>
Modulo is defined as the remainder of a division
that rounds the quotient towards minus infinity (floor division).
<p>
In case of overflows in integer arithmetic,
all operations <em>wrap around</em>.
<h3>3.4.2 – <a name="3.4.2">Bitwise Operators</a></h3><p>
Lua supports the following bitwise operators:
<ul>
<li><b><code>&</code>: </b>bitwise AND</li>
<li><b><code>|</code>: </b>bitwise OR</li>
<li><b><code>~</code>: </b>bitwise exclusive OR</li>
<li><b><code>>></code>: </b>right shift</li>
<li><b><code><<</code>: </b>left shift</li>
<li><b><code>~</code>: </b>unary bitwise NOT</li>
</ul>
<p>
All bitwise operations convert its operands to integers
(see <a href="#3.4.3">§3.4.3</a>),
operate on all bits of those integers,
and result in an integer.
<p>
Both right and left shifts fill the vacant bits with zeros.
Negative displacements shift to the other direction;
displacements with absolute values equal to or higher than
the number of bits in an integer
result in zero (as all bits are shifted out).
<h3>3.4.3 – <a name="3.4.3">Coercions and Conversions</a></h3><p>
Lua provides some automatic conversions between some
types and representations at run time.
Bitwise operators always convert float operands to integers.
Exponentiation and float division
always convert integer operands to floats.
All other arithmetic operations applied to mixed numbers
(integers and floats) convert the integer operand to a float.
The C API also converts both integers to floats and
floats to integers, as needed.
Moreover, string concatenation accepts numbers as arguments,
besides strings.
<p>
In a conversion from integer to float,
if the integer value has an exact representation as a float,
that is the result.
Otherwise,
the conversion gets the nearest higher or
the nearest lower representable value.
This kind of conversion never fails.
<p>
The conversion from float to integer
checks whether the float has an exact representation as an integer
(that is, the float has an integral value and
it is in the range of integer representation).
If it does, that representation is the result.
Otherwise, the conversion fails.
<p>
Several places in Lua coerce strings to numbers when necessary.
In particular,
the string library sets metamethods that try to coerce
strings to numbers in all arithmetic operations.
If the conversion fails,
the library calls the metamethod of the other operand
(if present) or it raises an error.
Note that bitwise operators do not do this coercion.
<p>
Nonetheless, it is always a good practice not to rely on these
implicit coercions, as they are not always applied;
in particular, <code>"1"==1</code> is false and <code>"1"<1</code> raises an error
(see <a href="#3.4.4">§3.4.4</a>).
These coercions exist mainly for compatibility and may be removed
in future versions of the language.
<p>
A string is converted to an integer or a float
following its syntax and the rules of the Lua lexer.
The string may have also leading and trailing whitespaces and a sign.
All conversions from strings to numbers
accept both a dot and the current locale mark
as the radix character.
(The Lua lexer, however, accepts only a dot.)
If the string is not a valid numeral,
the conversion fails.
If necessary, the result of this first step is then converted
to a specific number subtype following the previous rules
for conversions between floats and integers.
<p>
The conversion from numbers to strings uses a
non-specified human-readable format.
To convert numbers to strings in any specific way,
use the function <a href="#pdf-string.format"><code>string.format</code></a>.
<h3>3.4.4 – <a name="3.4.4">Relational Operators</a></h3><p>
Lua supports the following relational operators:
<ul>
<li><b><code>==</code>: </b>equality</li>
<li><b><code>~=</code>: </b>inequality</li>
<li><b><code><</code>: </b>less than</li>
<li><b><code>></code>: </b>greater than</li>
<li><b><code><=</code>: </b>less or equal</li>
<li><b><code>>=</code>: </b>greater or equal</li>
</ul><p>
These operators always result in <b>false</b> or <b>true</b>.
<p>
Equality (<code>==</code>) first compares the type of its operands.
If the types are different, then the result is <b>false</b>.
Otherwise, the values of the operands are compared.
Strings are equal if they have the same byte content.
Numbers are equal if they denote the same mathematical value.
<p>
Tables, userdata, and threads
are compared by reference:
two objects are considered equal only if they are the same object.
Every time you create a new object
(a table, a userdata, or a thread),
this new object is different from any previously existing object.
A function is always equal to itself.
Functions with any detectable difference
(different behavior, different definition) are always different.
Functions created at different times but with no detectable differences
may be classified as equal or not
(depending on internal caching details).
<p>
You can change the way that Lua compares tables and userdata
by using the <code>__eq</code> metamethod (see <a href="#2.4">§2.4</a>).
<p>
Equality comparisons do not convert strings to numbers
or vice versa.
Thus, <code>"0"==0</code> evaluates to <b>false</b>,
and <code>t[0]</code> and <code>t["0"]</code> denote different
entries in a table.
<p>
The operator <code>~=</code> is exactly the negation of equality (<code>==</code>).
<p>
The order operators work as follows.
If both arguments are numbers,
then they are compared according to their mathematical values,
regardless of their subtypes.
Otherwise, if both arguments are strings,
then their values are compared according to the current locale.
Otherwise, Lua tries to call the <code>__lt</code> or the <code>__le</code>
metamethod (see <a href="#2.4">§2.4</a>).
A comparison <code>a > b</code> is translated to <code>b < a</code>
and <code>a >= b</code> is translated to <code>b <= a</code>.
<p>
Following the IEEE 754 standard,
the special value NaN is considered neither less than,
nor equal to, nor greater than any value, including itself.
<h3>3.4.5 – <a name="3.4.5">Logical Operators</a></h3><p>
The logical operators in Lua are
<b>and</b>, <b>or</b>, and <b>not</b>.
Like the control structures (see <a href="#3.3.4">§3.3.4</a>),
all logical operators consider both <b>false</b> and <b>nil</b> as false
and anything else as true.
<p>
The negation operator <b>not</b> always returns <b>false</b> or <b>true</b>.
The conjunction operator <b>and</b> returns its first argument
if this value is <b>false</b> or <b>nil</b>;
otherwise, <b>and</b> returns its second argument.
The disjunction operator <b>or</b> returns its first argument
if this value is different from <b>nil</b> and <b>false</b>;
otherwise, <b>or</b> returns its second argument.
Both <b>and</b> and <b>or</b> use short-circuit evaluation;
that is,
the second operand is evaluated only if necessary.
Here are some examples:
<pre>
10 or 20 --> 10
10 or error() --> 10
nil or "a" --> "a"
nil and 10 --> nil
false and error() --> false
false and nil --> false
false or nil --> nil
10 and 20 --> 20
</pre>
<h3>3.4.6 – <a name="3.4.6">Concatenation</a></h3><p>
The string concatenation operator in Lua is
denoted by two dots ('<code>..</code>').
If both operands are strings or numbers,
then the numbers are converted to strings
in a non-specified format (see <a href="#3.4.3">§3.4.3</a>).
Otherwise, the <code>__concat</code> metamethod is called (see <a href="#2.4">§2.4</a>).
<h3>3.4.7 – <a name="3.4.7">The Length Operator</a></h3>
<p>
The length operator is denoted by the unary prefix operator <code>#</code>.
<p>
The length of a string is its number of bytes.
(That is the usual meaning of string length when each
character is one byte.)
<p>
The length operator applied on a table
returns a border in that table.
A <em>border</em> in a table <code>t</code> is any natural number
that satisfies the following condition:
<pre>
(border == 0 or t[border] ~= nil) and t[border + 1] == nil
</pre><p>
In words,
a border is any (natural) index present in the table
that is followed by an absent index
(or zero, when index 1 is absent).
<p>
A table with exactly one border is called a <em>sequence</em>.
For instance, the table <code>{10, 20, 30, 40, 50}</code> is a sequence,
as it has only one border (5).
The table <code>{10, 20, 30, nil, 50}</code> has two borders (3 and 5),
and therefore it is not a sequence.
(The <b>nil</b> at index 4 is called a <em>hole</em>.)
The table <code>{nil, 20, 30, nil, nil, 60, nil}</code>
has three borders (0, 3, and 6) and three holes
(at indices 1, 4, and 5),
so it is not a sequence, too.
The table <code>{}</code> is a sequence with border 0.
Note that non-natural keys do not interfere
with whether a table is a sequence.
<p>
When <code>t</code> is a sequence,
<code>#t</code> returns its only border,
which corresponds to the intuitive notion of the length of the sequence.
When <code>t</code> is not a sequence,
<code>#t</code> can return any of its borders.
(The exact one depends on details of
the internal representation of the table,
which in turn can depend on how the table was populated and
the memory addresses of its non-numeric keys.)
<p>
The computation of the length of a table
has a guaranteed worst time of <em>O(log n)</em>,
where <em>n</em> is the largest natural key in the table.
<p>
A program can modify the behavior of the length operator for
any value but strings through the <code>__len</code> metamethod (see <a href="#2.4">§2.4</a>).
<h3>3.4.8 – <a name="3.4.8">Precedence</a></h3><p>
Operator precedence in Lua follows the table below,
from lower to higher priority:
<pre>
or
and
< > <= >= ~= ==
|
~
&
<< >>
..
+ -
* / // %
unary operators (not # - ~)
^
</pre><p>
As usual,
you can use parentheses to change the precedences of an expression.
The concatenation ('<code>..</code>') and exponentiation ('<code>^</code>')
operators are right associative.
All other binary operators are left associative.
<h3>3.4.9 – <a name="3.4.9">Table Constructors</a></h3><p>
Table constructors are expressions that create tables.
Every time a constructor is evaluated, a new table is created.
A constructor can be used to create an empty table
or to create a table and initialize some of its fields.
The general syntax for constructors is
<pre>
tableconstructor ::= ‘<b>{</b>’ [fieldlist] ‘<b>}</b>’
fieldlist ::= field {fieldsep field} [fieldsep]
field ::= ‘<b>[</b>’ exp ‘<b>]</b>’ ‘<b>=</b>’ exp | Name ‘<b>=</b>’ exp | exp
fieldsep ::= ‘<b>,</b>’ | ‘<b>;</b>’
</pre>
<p>
Each field of the form <code>[exp1] = exp2</code> adds to the new table an entry
with key <code>exp1</code> and value <code>exp2</code>.
A field of the form <code>name = exp</code> is equivalent to
<code>["name"] = exp</code>.
Fields of the form <code>exp</code> are equivalent to
<code>[i] = exp</code>, where <code>i</code> are consecutive integers
starting with 1;
fields in the other formats do not affect this counting.
For example,
<pre>
a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
</pre><p>
is equivalent to
<pre>
do
local t = {}
t[f(1)] = g
t[1] = "x" -- 1st exp
t[2] = "y" -- 2nd exp
t.x = 1 -- t["x"] = 1
t[3] = f(x) -- 3rd exp
t[30] = 23
t[4] = 45 -- 4th exp
a = t
end
</pre>
<p>
The order of the assignments in a constructor is undefined.
(This order would be relevant only when there are repeated keys.)
<p>
If the last field in the list has the form <code>exp</code>
and the expression is a function call or a vararg expression,
then all values returned by this expression enter the list consecutively
(see <a href="#3.4.10">§3.4.10</a>).
<p>
The field list can have an optional trailing separator,
as a convenience for machine-generated code.
<h3>3.4.10 – <a name="3.4.10">Function Calls</a></h3><p>
A function call in Lua has the following syntax:
<pre>
functioncall ::= prefixexp args
</pre><p>
In a function call,
first prefixexp and args are evaluated.
If the value of prefixexp has type <em>function</em>,
then this function is called
with the given arguments.
Otherwise, if present,
the prefixexp <code>__call</code> metamethod is called:
its first argument is the value of prefixexp,
followed by the original call arguments
(see <a href="#2.4">§2.4</a>).
<p>
The form
<pre>
functioncall ::= prefixexp ‘<b>:</b>’ Name args
</pre><p>
can be used to emulate methods.
A call <code>v:name(<em>args</em>)</code>
is syntactic sugar for <code>v.name(v,<em>args</em>)</code>,
except that <code>v</code> is evaluated only once.
<p>
Arguments have the following syntax:
<pre>
args ::= ‘<b>(</b>’ [explist] ‘<b>)</b>’
args ::= tableconstructor
args ::= LiteralString
</pre><p>
All argument expressions are evaluated before the call.
A call of the form <code>f{<em>fields</em>}</code> is
syntactic sugar for <code>f({<em>fields</em>})</code>;
that is, the argument list is a single new table.
A call of the form <code>f'<em>string</em>'</code>
(or <code>f"<em>string</em>"</code> or <code>f[[<em>string</em>]]</code>)
is syntactic sugar for <code>f('<em>string</em>')</code>;
that is, the argument list is a single literal string.
<p>
A call of the form <code>return <em>functioncall</em></code> not in the
scope of a to-be-closed variable is called a <em>tail call</em>.
Lua implements <em>proper tail calls</em>
(or <em>proper tail recursion</em>):
in a tail call,
the called function reuses the stack entry of the calling function.
Therefore, there is no limit on the number of nested tail calls that
a program can execute.
However, a tail call erases any debug information about the
calling function.
Note that a tail call only happens with a particular syntax,
where the <b>return</b> has one single function call as argument,
and it is outside the scope of any to-be-closed variable.
This syntax makes the calling function return exactly
the returns of the called function,
without any intervening action.
So, none of the following examples are tail calls:
<pre>
return (f(x)) -- results adjusted to 1
return 2 * f(x) -- result multiplied by 2
return x, f(x) -- additional results
f(x); return -- results discarded
return x or f(x) -- results adjusted to 1
</pre>
<h3>3.4.11 – <a name="3.4.11">Function Definitions</a></h3>
<p>
The syntax for function definition is
<pre>
functiondef ::= <b>function</b> funcbody
funcbody ::= ‘<b>(</b>’ [parlist] ‘<b>)</b>’ block <b>end</b>
</pre>
<p>
The following syntactic sugar simplifies function definitions:
<pre>
stat ::= <b>function</b> funcname funcbody
stat ::= <b>local</b> <b>function</b> Name funcbody
funcname ::= Name {‘<b>.</b>’ Name} [‘<b>:</b>’ Name]
</pre><p>
The statement
<pre>
function f () <em>body</em> end
</pre><p>
translates to
<pre>
f = function () <em>body</em> end
</pre><p>
The statement
<pre>
function t.a.b.c.f () <em>body</em> end
</pre><p>
translates to
<pre>
t.a.b.c.f = function () <em>body</em> end
</pre><p>
The statement
<pre>
local function f () <em>body</em> end
</pre><p>
translates to
<pre>
local f; f = function () <em>body</em> end
</pre><p>
not to
<pre>
local f = function () <em>body</em> end
</pre><p>
(This only makes a difference when the body of the function
contains references to <code>f</code>.)
<p>
A function definition is an executable expression,
whose value has type <em>function</em>.
When Lua precompiles a chunk,
all its function bodies are precompiled too,
but they are not created yet.
Then, whenever Lua executes the function definition,
the function is <em>instantiated</em> (or <em>closed</em>).
This function instance, or <em>closure</em>,
is the final value of the expression.
<p>
Parameters act as local variables that are
initialized with the argument values:
<pre>
parlist ::= namelist [‘<b>,</b>’ ‘<b>...</b>’] | ‘<b>...</b>’
</pre><p>
When a Lua function is called,
it adjusts its list of arguments to
the length of its list of parameters,
unless the function is a <em>vararg function</em>,
which is indicated by three dots ('<code>...</code>')
at the end of its parameter list.
A vararg function does not adjust its argument list;
instead, it collects all extra arguments and supplies them
to the function through a <em>vararg expression</em>,
which is also written as three dots.
The value of this expression is a list of all actual extra arguments,
similar to a function with multiple results.
If a vararg expression is used inside another expression
or in the middle of a list of expressions,
then its return list is adjusted to one element.
If the expression is used as the last element of a list of expressions,
then no adjustment is made
(unless that last expression is enclosed in parentheses).
<p>
As an example, consider the following definitions:
<pre>
function f(a, b) end
function g(a, b, ...) end
function r() return 1,2,3 end
</pre><p>
Then, we have the following mapping from arguments to parameters and
to the vararg expression:
<pre>
CALL PARAMETERS
f(3) a=3, b=nil
f(3, 4) a=3, b=4
f(3, 4, 5) a=3, b=4
f(r(), 10) a=1, b=10
f(r()) a=1, b=2
g(3) a=3, b=nil, ... --> (nothing)
g(3, 4) a=3, b=4, ... --> (nothing)
g(3, 4, 5, 8) a=3, b=4, ... --> 5 8
g(5, r()) a=5, b=1, ... --> 2 3
</pre>
<p>
Results are returned using the <b>return</b> statement (see <a href="#3.3.4">§3.3.4</a>).
If control reaches the end of a function
without encountering a <b>return</b> statement,
then the function returns with no results.
<p>
There is a system-dependent limit on the number of values
that a function may return.
This limit is guaranteed to be greater than 1000.
<p>
The <em>colon</em> syntax
is used to emulate <em>methods</em>,
adding an implicit extra parameter <code>self</code> to the function.
Thus, the statement
<pre>
function t.a.b.c:f (<em>params</em>) <em>body</em> end
</pre><p>
is syntactic sugar for
<pre>
t.a.b.c.f = function (self, <em>params</em>) <em>body</em> end
</pre>
<h2>3.5 – <a name="3.5">Visibility Rules</a></h2>
<p>
Lua is a lexically scoped language.
The scope of a local variable begins at the first statement after
its declaration and lasts until the last non-void statement
of the innermost block that includes the declaration.
Consider the following example:
<pre>
x = 10 -- global variable
do -- new block
local x = x -- new 'x', with value 10
print(x) --> 10
x = x+1
do -- another block
local x = x+1 -- another 'x'
print(x) --> 12
end
print(x) --> 11
end
print(x) --> 10 (the global one)
</pre>
<p>
Notice that, in a declaration like <code>local x = x</code>,
the new <code>x</code> being declared is not in scope yet,
and so the second <code>x</code> refers to the outside variable.
<p>
Because of the lexical scoping rules,
local variables can be freely accessed by functions
defined inside their scope.
A local variable used by an inner function is called an <em>upvalue</em>
(or <em>external local variable</em>, or simply <em>external variable</em>)
inside the inner function.
<p>
Notice that each execution of a <b>local</b> statement
defines new local variables.
Consider the following example:
<pre>
a = {}
local x = 20
for i = 1, 10 do
local y = 0
a[i] = function () y = y + 1; return x + y end
end
</pre><p>
The loop creates ten closures
(that is, ten instances of the anonymous function).
Each of these closures uses a different <code>y</code> variable,
while all of them share the same <code>x</code>.
<h1>4 – <a name="4">The Application Program Interface</a></h1>
<p>
This section describes the C API for Lua, that is,
the set of C functions available to the host program to communicate
with Lua.
All API functions and related types and constants
are declared in the header file <a name="pdf-lua.h"><code>lua.h</code></a>.
<p>
Even when we use the term "function",
any facility in the API may be provided as a macro instead.
Except where stated otherwise,
all such macros use each of their arguments exactly once
(except for the first argument, which is always a Lua state),
and so do not generate any hidden side-effects.
<p>
As in most C libraries,
the Lua API functions do not check their arguments
for validity or consistency.
However, you can change this behavior by compiling Lua
with the macro <a name="pdf-LUA_USE_APICHECK"><code>LUA_USE_APICHECK</code></a> defined.
<p>
The Lua library is fully reentrant:
it has no global variables.
It keeps all information it needs in a dynamic structure,
called the <em>Lua state</em>.
<p>
Each Lua state has one or more threads,
which correspond to independent, cooperative lines of execution.
The type <a href="#lua_State"><code>lua_State</code></a> (despite its name) refers to a thread.
(Indirectly, through the thread, it also refers to the
Lua state associated to the thread.)
<p>
A pointer to a thread must be passed as the first argument to
every function in the library, except to <a href="#lua_newstate"><code>lua_newstate</code></a>,
which creates a Lua state from scratch and returns a pointer
to the <em>main thread</em> in the new state.
<h2>4.1 – <a name="4.1">The Stack</a></h2>
<p>
Lua uses a <em>virtual stack</em> to pass values to and from C.
Each element in this stack represents a Lua value
(<b>nil</b>, number, string, etc.).
Functions in the API can access this stack through the
Lua state parameter that they receive.
<p>
Whenever Lua calls C, the called function gets a new stack,
which is independent of previous stacks and of stacks of
C functions that are still active.
This stack initially contains any arguments to the C function
and it is where the C function can store temporary
Lua values and must push its results
to be returned to the caller (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
<p>
For convenience,
most query operations in the API do not follow a strict stack discipline.
Instead, they can refer to any element in the stack
by using an <em>index</em>:
A positive index represents an absolute stack position,
starting at 1 as the bottom of the stack;
a negative index represents an offset relative to the top of the stack.
More specifically, if the stack has <em>n</em> elements,
then index 1 represents the first element
(that is, the element that was pushed onto the stack first)
and
index <em>n</em> represents the last element;
index -1 also represents the last element
(that is, the element at the top)
and index <em>-n</em> represents the first element.
<h3>4.1.1 – <a name="4.1.1">Stack Size</a></h3>
<p>
When you interact with the Lua API,
you are responsible for ensuring consistency.
In particular,
<em>you are responsible for controlling stack overflow</em>.
When you call any API function,
you must ensure the stack has enough room to accommodate the results.
<p>
There is one exception to the above rule:
When you call a Lua function
without a fixed number of results (see <a href="#lua_call"><code>lua_call</code></a>),
Lua ensures that the stack has enough space for all results.
However, it does not ensure any extra space.
So, before pushing anything on the stack after such a call
you should use <a href="#lua_checkstack"><code>lua_checkstack</code></a>.
<p>
Whenever Lua calls C,
it ensures that the stack has space for
at least <a name="pdf-LUA_MINSTACK"><code>LUA_MINSTACK</code></a> extra elements;
that is, you can safely push up to <code>LUA_MINSTACK</code> values into it.
<code>LUA_MINSTACK</code> is defined as 20,
so that usually you do not have to worry about stack space
unless your code has loops pushing elements onto the stack.
Whenever necessary,
you can use the function <a href="#lua_checkstack"><code>lua_checkstack</code></a>
to ensure that the stack has enough space for pushing new elements.
<h3>4.1.2 – <a name="4.1.2">Valid and Acceptable Indices</a></h3>
<p>
Any function in the API that receives stack indices
works only with <em>valid indices</em> or <em>acceptable indices</em>.
<p>
A <em>valid index</em> is an index that refers to a
position that stores a modifiable Lua value.
It comprises stack indices between 1 and the stack top
(<code>1 ≤ abs(index) ≤ top</code>)
plus <em>pseudo-indices</em>,
which represent some positions that are accessible to C code
but that are not in the stack.
Pseudo-indices are used to access the registry (see <a href="#4.3">§4.3</a>)
and the upvalues of a C function (see <a href="#4.2">§4.2</a>).
<p>
Functions that do not need a specific mutable position,
but only a value (e.g., query functions),
can be called with acceptable indices.
An <em>acceptable index</em> can be any valid index,
but it also can be any positive index after the stack top
within the space allocated for the stack,
that is, indices up to the stack size.
(Note that 0 is never an acceptable index.)
Indices to upvalues (see <a href="#4.2">§4.2</a>) greater than the real number
of upvalues in the current C function are also acceptable (but invalid).
Except when noted otherwise,
functions in the API work with acceptable indices.
<p>
Acceptable indices serve to avoid extra tests
against the stack top when querying the stack.
For instance, a C function can query its third argument
without the need to check whether there is a third argument,
that is, without the need to check whether 3 is a valid index.
<p>
For functions that can be called with acceptable indices,
any non-valid index is treated as if it
contains a value of a virtual type <a name="pdf-LUA_TNONE"><code>LUA_TNONE</code></a>,
which behaves like a nil value.
<h3>4.1.3 – <a name="4.1.3">Pointers to strings</a></h3>
<p>
Several functions in the API return pointers (<code>const char*</code>)
to Lua strings in the stack.
(See <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>, <a href="#lua_pushlstring"><code>lua_pushlstring</code></a>,
<a href="#lua_pushstring"><code>lua_pushstring</code></a>, and <a href="#lua_tolstring"><code>lua_tolstring</code></a>.
See also <a href="#luaL_checklstring"><code>luaL_checklstring</code></a>, <a href="#luaL_checkstring"><code>luaL_checkstring</code></a>,
and <a href="#luaL_tolstring"><code>luaL_tolstring</code></a> in the auxiliary library.)
<p>
In general,
Lua's garbage collection can free or move internal memory
and then invalidate pointers to internal strings.
To allow a safe use of these pointers,
The API guarantees that any pointer to a string in a stack index
is valid while the string value at that index is not removed from the stack.
(It can be moved to another index, though.)
When the index is a pseudo-index (referring to an upvalue),
the pointer is valid while the corresponding call is active and
the corresponding upvalue is not modified.
<p>
Some functions in the debug interface
also return pointers to strings,
namely <a href="#lua_getlocal"><code>lua_getlocal</code></a>, <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>,
<a href="#lua_setlocal"><code>lua_setlocal</code></a>, and <a href="#lua_setupvalue"><code>lua_setupvalue</code></a>.
For these functions, the pointer is guaranteed to
be valid while the caller function is active and
the given closure (if one was given) is in the stack.
<p>
Except for these guarantees,
the garbage collector is free to invalidate
any pointer to internal strings.
<h2>4.2 – <a name="4.2">C Closures</a></h2>
<p>
When a C function is created,
it is possible to associate some values with it,
thus creating a <em>C closure</em>
(see <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>);
these values are called <em>upvalues</em> and are
accessible to the function whenever it is called.
<p>
Whenever a C function is called,
its upvalues are located at specific pseudo-indices.
These pseudo-indices are produced by the macro
<a href="#lua_upvalueindex"><code>lua_upvalueindex</code></a>.
The first upvalue associated with a function is at index
<code>lua_upvalueindex(1)</code>, and so on.
Any access to <code>lua_upvalueindex(<em>n</em>)</code>,
where <em>n</em> is greater than the number of upvalues of the
current function
(but not greater than 256,
which is one plus the maximum number of upvalues in a closure),
produces an acceptable but invalid index.
<p>
A C closure can also change the values
of its corresponding upvalues.
<h2>4.3 – <a name="4.3">Registry</a></h2>
<p>
Lua provides a <em>registry</em>,
a predefined table that can be used by any C code to
store whatever Lua values it needs to store.
The registry table is always accessible at pseudo-index
<a name="pdf-LUA_REGISTRYINDEX"><code>LUA_REGISTRYINDEX</code></a>.
Any C library can store data into this table,
but it must take care to choose keys
that are different from those used
by other libraries, to avoid collisions.
Typically, you should use as key a string containing your library name,
or a light userdata with the address of a C object in your code,
or any Lua object created by your code.
As with variable names,
string keys starting with an underscore followed by
uppercase letters are reserved for Lua.
<p>
The integer keys in the registry are used
by the reference mechanism (see <a href="#luaL_ref"><code>luaL_ref</code></a>)
and by some predefined values.
Therefore, integer keys in the registry
must not be used for other purposes.
<p>
When you create a new Lua state,
its registry comes with some predefined values.
These predefined values are indexed with integer keys
defined as constants in <code>lua.h</code>.
The following constants are defined:
<ul>
<li><b><a name="pdf-LUA_RIDX_MAINTHREAD"><code>LUA_RIDX_MAINTHREAD</code></a>: </b> At this index the registry has
the main thread of the state.
(The main thread is the one created together with the state.)
</li>
<li><b><a name="pdf-LUA_RIDX_GLOBALS"><code>LUA_RIDX_GLOBALS</code></a>: </b> At this index the registry has
the global environment.
</li>
</ul>
<h2>4.4 – <a name="4.4">Error Handling in C</a></h2>
<p>
Internally, Lua uses the C <code>longjmp</code> facility to handle errors.
(Lua will use exceptions if you compile it as C++;
search for <code>LUAI_THROW</code> in the source code for details.)
When Lua faces any error,
such as a memory allocation error or a type error,
it <em>raises</em> an error;
that is, it does a long jump.
A <em>protected environment</em> uses <code>setjmp</code>
to set a recovery point;
any error jumps to the most recent active recovery point.
<p>
Inside a C function you can raise an error explicitly
by calling <a href="#lua_error"><code>lua_error</code></a>.
<p>
Most functions in the API can raise an error,
for instance due to a memory allocation error.
The documentation for each function indicates whether
it can raise errors.
<p>
If an error happens outside any protected environment,
Lua calls a <em>panic function</em> (see <a href="#lua_atpanic"><code>lua_atpanic</code></a>)
and then calls <code>abort</code>,
thus exiting the host application.
Your panic function can avoid this exit by
never returning
(e.g., doing a long jump to your own recovery point outside Lua).
<p>
The panic function,
as its name implies,
is a mechanism of last resort.
Programs should avoid it.
As a general rule,
when a C function is called by Lua with a Lua state,
it can do whatever it wants on that Lua state,
as it should be already protected.
However,
when C code operates on other Lua states
(e.g., a Lua-state argument to the function,
a Lua state stored in the registry, or
the result of <a href="#lua_newthread"><code>lua_newthread</code></a>),
it should use them only in API calls that cannot raise errors.
<p>
The panic function runs as if it were a message handler (see <a href="#2.3">§2.3</a>);
in particular, the error object is on the top of the stack.
However, there is no guarantee about stack space.
To push anything on the stack,
the panic function must first check the available space (see <a href="#4.1.1">§4.1.1</a>).
<h3>4.4.1 – <a name="4.4.1">Status Codes</a></h3>
<p>
Several functions that report errors in the API use the following
status codes to indicate different kinds of errors or other conditions:
<ul>
<li><b><a name="pdf-LUA_OK"><code>LUA_OK</code></a> (0): </b> no errors.</li>
<li><b><a name="pdf-LUA_ERRRUN"><code>LUA_ERRRUN</code></a>: </b> a runtime error.</li>
<li><b><a name="pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>: </b>
memory allocation error.
For such errors, Lua does not call the message handler.
</li>
<li><b><a name="pdf-LUA_ERRERR"><code>LUA_ERRERR</code></a>: </b> error while running the message handler.</li>
<li><b><a name="pdf-LUA_ERRSYNTAX"><code>LUA_ERRSYNTAX</code></a>: </b> syntax error during precompilation.</li>
<li><b><a name="pdf-LUA_YIELD"><code>LUA_YIELD</code></a>: </b> the thread (coroutine) yields.</li>
<li><b><a name="pdf-LUA_ERRFILE"><code>LUA_ERRFILE</code></a>: </b> a file-related error;
e.g., it cannot open or read the file.</li>
</ul><p>
These constants are defined in the header file <code>lua.h</code>.
<h2>4.5 – <a name="4.5">Handling Yields in C</a></h2>
<p>
Internally, Lua uses the C <code>longjmp</code> facility to yield a coroutine.
Therefore, if a C function <code>foo</code> calls an API function
and this API function yields
(directly or indirectly by calling another function that yields),
Lua cannot return to <code>foo</code> any more,
because the <code>longjmp</code> removes its frame from the C stack.
<p>
To avoid this kind of problem,
Lua raises an error whenever it tries to yield across an API call,
except for three functions:
<a href="#lua_yieldk"><code>lua_yieldk</code></a>, <a href="#lua_callk"><code>lua_callk</code></a>, and <a href="#lua_pcallk"><code>lua_pcallk</code></a>.
All those functions receive a <em>continuation function</em>
(as a parameter named <code>k</code>) to continue execution after a yield.
<p>
We need to set some terminology to explain continuations.
We have a C function called from Lua which we will call
the <em>original function</em>.
This original function then calls one of those three functions in the C API,
which we will call the <em>callee function</em>,
that then yields the current thread.
This can happen when the callee function is <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
or when the callee function is either <a href="#lua_callk"><code>lua_callk</code></a> or <a href="#lua_pcallk"><code>lua_pcallk</code></a>
and the function called by them yields.
<p>
Suppose the running thread yields while executing the callee function.
After the thread resumes,
it eventually will finish running the callee function.
However,
the callee function cannot return to the original function,
because its frame in the C stack was destroyed by the yield.
Instead, Lua calls a <em>continuation function</em>,
which was given as an argument to the callee function.
As the name implies,
the continuation function should continue the task
of the original function.
<p>
As an illustration, consider the following function:
<pre>
int original_function (lua_State *L) {
... /* code 1 */
status = lua_pcall(L, n, m, h); /* calls Lua */
... /* code 2 */
}
</pre><p>
Now we want to allow
the Lua code being run by <a href="#lua_pcall"><code>lua_pcall</code></a> to yield.
First, we can rewrite our function like here:
<pre>
int k (lua_State *L, int status, lua_KContext ctx) {
... /* code 2 */
}
int original_function (lua_State *L) {
... /* code 1 */
return k(L, lua_pcall(L, n, m, h), ctx);
}
</pre><p>
In the above code,
the new function <code>k</code> is a
<em>continuation function</em> (with type <a href="#lua_KFunction"><code>lua_KFunction</code></a>),
which should do all the work that the original function
was doing after calling <a href="#lua_pcall"><code>lua_pcall</code></a>.
Now, we must inform Lua that it must call <code>k</code> if the Lua code
being executed by <a href="#lua_pcall"><code>lua_pcall</code></a> gets interrupted in some way
(errors or yielding),
so we rewrite the code as here,
replacing <a href="#lua_pcall"><code>lua_pcall</code></a> by <a href="#lua_pcallk"><code>lua_pcallk</code></a>:
<pre>
int original_function (lua_State *L) {
... /* code 1 */
return k(L, lua_pcallk(L, n, m, h, ctx2, k), ctx1);
}
</pre><p>
Note the external, explicit call to the continuation:
Lua will call the continuation only if needed, that is,
in case of errors or resuming after a yield.
If the called function returns normally without ever yielding,
<a href="#lua_pcallk"><code>lua_pcallk</code></a> (and <a href="#lua_callk"><code>lua_callk</code></a>) will also return normally.
(Of course, instead of calling the continuation in that case,
you can do the equivalent work directly inside the original function.)
<p>
Besides the Lua state,
the continuation function has two other parameters:
the final status of the call and the context value (<code>ctx</code>) that
was passed originally to <a href="#lua_pcallk"><code>lua_pcallk</code></a>.
Lua does not use this context value;
it only passes this value from the original function to the
continuation function.
For <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
the status is the same value that would be returned by <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
except that it is <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> when being executed after a yield
(instead of <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>).
For <a href="#lua_yieldk"><code>lua_yieldk</code></a> and <a href="#lua_callk"><code>lua_callk</code></a>,
the status is always <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> when Lua calls the continuation.
(For these two functions,
Lua will not call the continuation in case of errors,
because they do not handle errors.)
Similarly, when using <a href="#lua_callk"><code>lua_callk</code></a>,
you should call the continuation function
with <a href="#pdf-LUA_OK"><code>LUA_OK</code></a> as the status.
(For <a href="#lua_yieldk"><code>lua_yieldk</code></a>, there is not much point in calling
directly the continuation function,
because <a href="#lua_yieldk"><code>lua_yieldk</code></a> usually does not return.)
<p>
Lua treats the continuation function as if it were the original function.
The continuation function receives the same Lua stack
from the original function,
in the same state it would be if the callee function had returned.
(For instance,
after a <a href="#lua_callk"><code>lua_callk</code></a> the function and its arguments are
removed from the stack and replaced by the results from the call.)
It also has the same upvalues.
Whatever it returns is handled by Lua as if it were the return
of the original function.
<h2>4.6 – <a name="4.6">Functions and Types</a></h2>
<p>
Here we list all functions and types from the C API in
alphabetical order.
Each function has an indicator like this:
<span class="apii">[-o, +p, <em>x</em>]</span>
<p>
The first field, <code>o</code>,
is how many elements the function pops from the stack.
The second field, <code>p</code>,
is how many elements the function pushes onto the stack.
(Any function always pushes its results after popping its arguments.)
A field in the form <code>x|y</code> means the function can push (or pop)
<code>x</code> or <code>y</code> elements,
depending on the situation;
an interrogation mark '<code>?</code>' means that
we cannot know how many elements the function pops/pushes
by looking only at its arguments.
(For instance, they may depend on what is in the stack.)
The third field, <code>x</code>,
tells whether the function may raise errors:
'<code>-</code>' means the function never raises any error;
'<code>m</code>' means the function may raise only out-of-memory errors;
'<code>v</code>' means the function may raise the errors explained in the text;
'<code>e</code>' means the function can run arbitrary Lua code,
either directly or through metamethods,
and therefore may raise any errors.
<hr><h3><a name="lua_absindex"><code>lua_absindex</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_absindex (lua_State *L, int idx);</pre>
<p>
Converts the acceptable index <code>idx</code>
into an equivalent absolute index
(that is, one that does not depend on the stack size).
<hr><h3><a name="lua_Alloc"><code>lua_Alloc</code></a></h3>
<pre>typedef void * (*lua_Alloc) (void *ud,
void *ptr,
size_t osize,
size_t nsize);</pre>
<p>
The type of the memory-allocation function used by Lua states.
The allocator function must provide a
functionality similar to <code>realloc</code>,
but not exactly the same.
Its arguments are
<code>ud</code>, an opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>;
<code>ptr</code>, a pointer to the block being allocated/reallocated/freed;
<code>osize</code>, the original size of the block or some code about what
is being allocated;
and <code>nsize</code>, the new size of the block.
<p>
When <code>ptr</code> is not <code>NULL</code>,
<code>osize</code> is the size of the block pointed by <code>ptr</code>,
that is, the size given when it was allocated or reallocated.
<p>
When <code>ptr</code> is <code>NULL</code>,
<code>osize</code> encodes the kind of object that Lua is allocating.
<code>osize</code> is any of
<a href="#pdf-LUA_TSTRING"><code>LUA_TSTRING</code></a>, <a href="#pdf-LUA_TTABLE"><code>LUA_TTABLE</code></a>, <a href="#pdf-LUA_TFUNCTION"><code>LUA_TFUNCTION</code></a>,
<a href="#pdf-LUA_TUSERDATA"><code>LUA_TUSERDATA</code></a>, or <a href="#pdf-LUA_TTHREAD"><code>LUA_TTHREAD</code></a> when (and only when)
Lua is creating a new object of that type.
When <code>osize</code> is some other value,
Lua is allocating memory for something else.
<p>
Lua assumes the following behavior from the allocator function:
<p>
When <code>nsize</code> is zero,
the allocator must behave like <code>free</code>
and then return <code>NULL</code>.
<p>
When <code>nsize</code> is not zero,
the allocator must behave like <code>realloc</code>.
In particular, the allocator returns <code>NULL</code>
if and only if it cannot fulfill the request.
<p>
Here is a simple implementation for the allocator function.
It is used in the auxiliary library by <a href="#luaL_newstate"><code>luaL_newstate</code></a>.
<pre>
static void *l_alloc (void *ud, void *ptr, size_t osize,
size_t nsize) {
(void)ud; (void)osize; /* not used */
if (nsize == 0) {
free(ptr);
return NULL;
}
else
return realloc(ptr, nsize);
}
</pre><p>
Note that Standard C ensures
that <code>free(NULL)</code> has no effect and that
<code>realloc(NULL,size)</code> is equivalent to <code>malloc(size)</code>.
<hr><h3><a name="lua_arith"><code>lua_arith</code></a></h3><p>
<span class="apii">[-(2|1), +1, <em>e</em>]</span>
<pre>void lua_arith (lua_State *L, int op);</pre>
<p>
Performs an arithmetic or bitwise operation over the two values
(or one, in the case of negations)
at the top of the stack,
with the value on the top being the second operand,
pops these values, and pushes the result of the operation.
The function follows the semantics of the corresponding Lua operator
(that is, it may call metamethods).
<p>
The value of <code>op</code> must be one of the following constants:
<ul>
<li><b><a name="pdf-LUA_OPADD"><code>LUA_OPADD</code></a>: </b> performs addition (<code>+</code>)</li>
<li><b><a name="pdf-LUA_OPSUB"><code>LUA_OPSUB</code></a>: </b> performs subtraction (<code>-</code>)</li>
<li><b><a name="pdf-LUA_OPMUL"><code>LUA_OPMUL</code></a>: </b> performs multiplication (<code>*</code>)</li>
<li><b><a name="pdf-LUA_OPDIV"><code>LUA_OPDIV</code></a>: </b> performs float division (<code>/</code>)</li>
<li><b><a name="pdf-LUA_OPIDIV"><code>LUA_OPIDIV</code></a>: </b> performs floor division (<code>//</code>)</li>
<li><b><a name="pdf-LUA_OPMOD"><code>LUA_OPMOD</code></a>: </b> performs modulo (<code>%</code>)</li>
<li><b><a name="pdf-LUA_OPPOW"><code>LUA_OPPOW</code></a>: </b> performs exponentiation (<code>^</code>)</li>
<li><b><a name="pdf-LUA_OPUNM"><code>LUA_OPUNM</code></a>: </b> performs mathematical negation (unary <code>-</code>)</li>
<li><b><a name="pdf-LUA_OPBNOT"><code>LUA_OPBNOT</code></a>: </b> performs bitwise NOT (<code>~</code>)</li>
<li><b><a name="pdf-LUA_OPBAND"><code>LUA_OPBAND</code></a>: </b> performs bitwise AND (<code>&</code>)</li>
<li><b><a name="pdf-LUA_OPBOR"><code>LUA_OPBOR</code></a>: </b> performs bitwise OR (<code>|</code>)</li>
<li><b><a name="pdf-LUA_OPBXOR"><code>LUA_OPBXOR</code></a>: </b> performs bitwise exclusive OR (<code>~</code>)</li>
<li><b><a name="pdf-LUA_OPSHL"><code>LUA_OPSHL</code></a>: </b> performs left shift (<code><<</code>)</li>
<li><b><a name="pdf-LUA_OPSHR"><code>LUA_OPSHR</code></a>: </b> performs right shift (<code>>></code>)</li>
</ul>
<hr><h3><a name="lua_atpanic"><code>lua_atpanic</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);</pre>
<p>
Sets a new panic function and returns the old one (see <a href="#4.4">§4.4</a>).
<hr><h3><a name="lua_call"><code>lua_call</code></a></h3><p>
<span class="apii">[-(nargs+1), +nresults, <em>e</em>]</span>
<pre>void lua_call (lua_State *L, int nargs, int nresults);</pre>
<p>
Calls a function.
Like regular Lua calls,
<code>lua_call</code> respects the <code>__call</code> metamethod.
So, here the word "function"
means any callable value.
<p>
To do a call you must use the following protocol:
first, the function to be called is pushed onto the stack;
then, the arguments to the call are pushed
in direct order;
that is, the first argument is pushed first.
Finally you call <a href="#lua_call"><code>lua_call</code></a>;
<code>nargs</code> is the number of arguments that you pushed onto the stack.
When the function returns,
all arguments and the function value are popped
and the call results are pushed onto the stack.
The number of results is adjusted to <code>nresults</code>,
unless <code>nresults</code> is <a name="pdf-LUA_MULTRET"><code>LUA_MULTRET</code></a>.
In this case, all results from the function are pushed;
Lua takes care that the returned values fit into the stack space,
but it does not ensure any extra space in the stack.
The function results are pushed onto the stack in direct order
(the first result is pushed first),
so that after the call the last result is on the top of the stack.
<p>
Any error while calling and running the function is propagated upwards
(with a <code>longjmp</code>).
<p>
The following example shows how the host program can do the
equivalent to this Lua code:
<pre>
a = f("how", t.x, 14)
</pre><p>
Here it is in C:
<pre>
lua_getglobal(L, "f"); /* function to be called */
lua_pushliteral(L, "how"); /* 1st argument */
lua_getglobal(L, "t"); /* table to be indexed */
lua_getfield(L, -1, "x"); /* push result of t.x (2nd arg) */
lua_remove(L, -2); /* remove 't' from the stack */
lua_pushinteger(L, 14); /* 3rd argument */
lua_call(L, 3, 1); /* call 'f' with 3 arguments and 1 result */
lua_setglobal(L, "a"); /* set global 'a' */
</pre><p>
Note that the code above is <em>balanced</em>:
at its end, the stack is back to its original configuration.
This is considered good programming practice.
<hr><h3><a name="lua_callk"><code>lua_callk</code></a></h3><p>
<span class="apii">[-(nargs + 1), +nresults, <em>e</em>]</span>
<pre>void lua_callk (lua_State *L,
int nargs,
int nresults,
lua_KContext ctx,
lua_KFunction k);</pre>
<p>
This function behaves exactly like <a href="#lua_call"><code>lua_call</code></a>,
but allows the called function to yield (see <a href="#4.5">§4.5</a>).
<hr><h3><a name="lua_CFunction"><code>lua_CFunction</code></a></h3>
<pre>typedef int (*lua_CFunction) (lua_State *L);</pre>
<p>
Type for C functions.
<p>
In order to communicate properly with Lua,
a C function must use the following protocol,
which defines the way parameters and results are passed:
a C function receives its arguments from Lua in its stack
in direct order (the first argument is pushed first).
So, when the function starts,
<code>lua_gettop(L)</code> returns the number of arguments received by the function.
The first argument (if any) is at index 1
and its last argument is at index <code>lua_gettop(L)</code>.
To return values to Lua, a C function just pushes them onto the stack,
in direct order (the first result is pushed first),
and returns in C the number of results.
Any other value in the stack below the results will be properly
discarded by Lua.
Like a Lua function, a C function called by Lua can also return
many results.
<p>
As an example, the following function receives a variable number
of numeric arguments and returns their average and their sum:
<pre>
static int foo (lua_State *L) {
int n = lua_gettop(L); /* number of arguments */
lua_Number sum = 0.0;
int i;
for (i = 1; i <= n; i++) {
if (!lua_isnumber(L, i)) {
lua_pushliteral(L, "incorrect argument");
lua_error(L);
}
sum += lua_tonumber(L, i);
}
lua_pushnumber(L, sum/n); /* first result */
lua_pushnumber(L, sum); /* second result */
return 2; /* number of results */
}
</pre>
<hr><h3><a name="lua_checkstack"><code>lua_checkstack</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_checkstack (lua_State *L, int n);</pre>
<p>
Ensures that the stack has space for at least <code>n</code> extra elements,
that is, that you can safely push up to <code>n</code> values into it.
It returns false if it cannot fulfill the request,
either because it would cause the stack
to be greater than a fixed maximum size
(typically at least several thousand elements) or
because it cannot allocate memory for the extra space.
This function never shrinks the stack;
if the stack already has space for the extra elements,
it is left unchanged.
<hr><h3><a name="lua_close"><code>lua_close</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void lua_close (lua_State *L);</pre>
<p>
Close all active to-be-closed variables in the main thread,
release all objects in the given Lua state
(calling the corresponding garbage-collection metamethods, if any),
and frees all dynamic memory used by this state.
<p>
On several platforms, you may not need to call this function,
because all resources are naturally released when the host program ends.
On the other hand, long-running programs that create multiple states,
such as daemons or web servers,
will probably need to close states as soon as they are not needed.
<hr><h3><a name="lua_closeslot"><code>lua_closeslot</code></a></h3><p>
<span class="apii">[-0, +0, <em>e</em>]</span>
<pre>void lua_closeslot (lua_State *L, int index);</pre>
<p>
Close the to-be-closed slot at the given index and set its value to <b>nil</b>.
The index must be the last index previously marked to be closed
(see <a href="#lua_toclose"><code>lua_toclose</code></a>) that is still active (that is, not closed yet).
<p>
A <code>__close</code> metamethod cannot yield
when called through this function.
<p>
(Exceptionally, this function was introduced in release 5.4.3.
It is not present in previous 5.4 releases.)
<hr><h3><a name="lua_compare"><code>lua_compare</code></a></h3><p>
<span class="apii">[-0, +0, <em>e</em>]</span>
<pre>int lua_compare (lua_State *L, int index1, int index2, int op);</pre>
<p>
Compares two Lua values.
Returns 1 if the value at index <code>index1</code> satisfies <code>op</code>
when compared with the value at index <code>index2</code>,
following the semantics of the corresponding Lua operator
(that is, it may call metamethods).
Otherwise returns 0.
Also returns 0 if any of the indices is not valid.
<p>
The value of <code>op</code> must be one of the following constants:
<ul>
<li><b><a name="pdf-LUA_OPEQ"><code>LUA_OPEQ</code></a>: </b> compares for equality (<code>==</code>)</li>
<li><b><a name="pdf-LUA_OPLT"><code>LUA_OPLT</code></a>: </b> compares for less than (<code><</code>)</li>
<li><b><a name="pdf-LUA_OPLE"><code>LUA_OPLE</code></a>: </b> compares for less or equal (<code><=</code>)</li>
</ul>
<hr><h3><a name="lua_concat"><code>lua_concat</code></a></h3><p>
<span class="apii">[-n, +1, <em>e</em>]</span>
<pre>void lua_concat (lua_State *L, int n);</pre>
<p>
Concatenates the <code>n</code> values at the top of the stack,
pops them, and leaves the result on the top.
If <code>n</code> is 1, the result is the single value on the stack
(that is, the function does nothing);
if <code>n</code> is 0, the result is the empty string.
Concatenation is performed following the usual semantics of Lua
(see <a href="#3.4.6">§3.4.6</a>).
<hr><h3><a name="lua_copy"><code>lua_copy</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void lua_copy (lua_State *L, int fromidx, int toidx);</pre>
<p>
Copies the element at index <code>fromidx</code>
into the valid index <code>toidx</code>,
replacing the value at that position.
Values at other positions are not affected.
<hr><h3><a name="lua_createtable"><code>lua_createtable</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>void lua_createtable (lua_State *L, int narr, int nrec);</pre>
<p>
Creates a new empty table and pushes it onto the stack.
Parameter <code>narr</code> is a hint for how many elements the table
will have as a sequence;
parameter <code>nrec</code> is a hint for how many other elements
the table will have.
Lua may use these hints to preallocate memory for the new table.
This preallocation may help performance when you know in advance
how many elements the table will have.
Otherwise you can use the function <a href="#lua_newtable"><code>lua_newtable</code></a>.
<hr><h3><a name="lua_dump"><code>lua_dump</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_dump (lua_State *L,
lua_Writer writer,
void *data,
int strip);</pre>
<p>
Dumps a function as a binary chunk.
Receives a Lua function on the top of the stack
and produces a binary chunk that,
if loaded again,
results in a function equivalent to the one dumped.
As it produces parts of the chunk,
<a href="#lua_dump"><code>lua_dump</code></a> calls function <code>writer</code> (see <a href="#lua_Writer"><code>lua_Writer</code></a>)
with the given <code>data</code>
to write them.
<p>
If <code>strip</code> is true,
the binary representation may not include all debug information
about the function,
to save space.
<p>
The value returned is the error code returned by the last
call to the writer;
0 means no errors.
<p>
This function does not pop the Lua function from the stack.
<hr><h3><a name="lua_error"><code>lua_error</code></a></h3><p>
<span class="apii">[-1, +0, <em>v</em>]</span>
<pre>int lua_error (lua_State *L);</pre>
<p>
Raises a Lua error,
using the value on the top of the stack as the error object.
This function does a long jump,
and therefore never returns
(see <a href="#luaL_error"><code>luaL_error</code></a>).
<hr><h3><a name="lua_gc"><code>lua_gc</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_gc (lua_State *L, int what, ...);</pre>
<p>
Controls the garbage collector.
<p>
This function performs several tasks,
according to the value of the parameter <code>what</code>.
For options that need extra arguments,
they are listed after the option.
<ul>
<li><b><code>LUA_GCCOLLECT</code>: </b>
Performs a full garbage-collection cycle.
</li>
<li><b><code>LUA_GCSTOP</code>: </b>
Stops the garbage collector.
</li>
<li><b><code>LUA_GCRESTART</code>: </b>
Restarts the garbage collector.
</li>
<li><b><code>LUA_GCCOUNT</code>: </b>
Returns the current amount of memory (in Kbytes) in use by Lua.
</li>
<li><b><code>LUA_GCCOUNTB</code>: </b>
Returns the remainder of dividing the current amount of bytes of
memory in use by Lua by 1024.
</li>
<li><b><code>LUA_GCSTEP</code> <code>(int stepsize)</code>: </b>
Performs an incremental step of garbage collection,
corresponding to the allocation of <code>stepsize</code> Kbytes.
</li>
<li><b><code>LUA_GCISRUNNING</code>: </b>
Returns a boolean that tells whether the collector is running
(i.e., not stopped).
</li>
<li><b><code>LUA_GCINC</code> (int pause, int stepmul, stepsize): </b>
Changes the collector to incremental mode
with the given parameters (see <a href="#2.5.1">§2.5.1</a>).
Returns the previous mode (<code>LUA_GCGEN</code> or <code>LUA_GCINC</code>).
</li>
<li><b><code>LUA_GCGEN</code> (int minormul, int majormul): </b>
Changes the collector to generational mode
with the given parameters (see <a href="#2.5.2">§2.5.2</a>).
Returns the previous mode (<code>LUA_GCGEN</code> or <code>LUA_GCINC</code>).
</li>
</ul><p>
For more details about these options,
see <a href="#pdf-collectgarbage"><code>collectgarbage</code></a>.
<hr><h3><a name="lua_getallocf"><code>lua_getallocf</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_Alloc lua_getallocf (lua_State *L, void **ud);</pre>
<p>
Returns the memory-allocation function of a given state.
If <code>ud</code> is not <code>NULL</code>, Lua stores in <code>*ud</code> the
opaque pointer given when the memory-allocator function was set.
<hr><h3><a name="lua_getfield"><code>lua_getfield</code></a></h3><p>
<span class="apii">[-0, +1, <em>e</em>]</span>
<pre>int lua_getfield (lua_State *L, int index, const char *k);</pre>
<p>
Pushes onto the stack the value <code>t[k]</code>,
where <code>t</code> is the value at the given index.
As in Lua, this function may trigger a metamethod
for the "index" event (see <a href="#2.4">§2.4</a>).
<p>
Returns the type of the pushed value.
<hr><h3><a name="lua_getextraspace"><code>lua_getextraspace</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void *lua_getextraspace (lua_State *L);</pre>
<p>
Returns a pointer to a raw memory area associated with the
given Lua state.
The application can use this area for any purpose;
Lua does not use it for anything.
<p>
Each new thread has this area initialized with a copy
of the area of the main thread.
<p>
By default, this area has the size of a pointer to void,
but you can recompile Lua with a different size for this area.
(See <code>LUA_EXTRASPACE</code> in <code>luaconf.h</code>.)
<hr><h3><a name="lua_getglobal"><code>lua_getglobal</code></a></h3><p>
<span class="apii">[-0, +1, <em>e</em>]</span>
<pre>int lua_getglobal (lua_State *L, const char *name);</pre>
<p>
Pushes onto the stack the value of the global <code>name</code>.
Returns the type of that value.
<hr><h3><a name="lua_geti"><code>lua_geti</code></a></h3><p>
<span class="apii">[-0, +1, <em>e</em>]</span>
<pre>int lua_geti (lua_State *L, int index, lua_Integer i);</pre>
<p>
Pushes onto the stack the value <code>t[i]</code>,
where <code>t</code> is the value at the given index.
As in Lua, this function may trigger a metamethod
for the "index" event (see <a href="#2.4">§2.4</a>).
<p>
Returns the type of the pushed value.
<hr><h3><a name="lua_getmetatable"><code>lua_getmetatable</code></a></h3><p>
<span class="apii">[-0, +(0|1), –]</span>
<pre>int lua_getmetatable (lua_State *L, int index);</pre>
<p>
If the value at the given index has a metatable,
the function pushes that metatable onto the stack and returns 1.
Otherwise,
the function returns 0 and pushes nothing on the stack.
<hr><h3><a name="lua_gettable"><code>lua_gettable</code></a></h3><p>
<span class="apii">[-1, +1, <em>e</em>]</span>
<pre>int lua_gettable (lua_State *L, int index);</pre>
<p>
Pushes onto the stack the value <code>t[k]</code>,
where <code>t</code> is the value at the given index
and <code>k</code> is the value on the top of the stack.
<p>
This function pops the key from the stack,
pushing the resulting value in its place.
As in Lua, this function may trigger a metamethod
for the "index" event (see <a href="#2.4">§2.4</a>).
<p>
Returns the type of the pushed value.
<hr><h3><a name="lua_gettop"><code>lua_gettop</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_gettop (lua_State *L);</pre>
<p>
Returns the index of the top element in the stack.
Because indices start at 1,
this result is equal to the number of elements in the stack;
in particular, 0 means an empty stack.
<hr><h3><a name="lua_getiuservalue"><code>lua_getiuservalue</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>int lua_getiuservalue (lua_State *L, int index, int n);</pre>
<p>
Pushes onto the stack the <code>n</code>-th user value associated with the
full userdata at the given index and
returns the type of the pushed value.
<p>
If the userdata does not have that value,
pushes <b>nil</b> and returns <a href="#pdf-LUA_TNONE"><code>LUA_TNONE</code></a>.
<hr><h3><a name="lua_insert"><code>lua_insert</code></a></h3><p>
<span class="apii">[-1, +1, –]</span>
<pre>void lua_insert (lua_State *L, int index);</pre>
<p>
Moves the top element into the given valid index,
shifting up the elements above this index to open space.
This function cannot be called with a pseudo-index,
because a pseudo-index is not an actual stack position.
<hr><h3><a name="lua_Integer"><code>lua_Integer</code></a></h3>
<pre>typedef ... lua_Integer;</pre>
<p>
The type of integers in Lua.
<p>
By default this type is <code>long long</code>,
(usually a 64-bit two-complement integer),
but that can be changed to <code>long</code> or <code>int</code>
(usually a 32-bit two-complement integer).
(See <code>LUA_INT_TYPE</code> in <code>luaconf.h</code>.)
<p>
Lua also defines the constants
<a name="pdf-LUA_MININTEGER"><code>LUA_MININTEGER</code></a> and <a name="pdf-LUA_MAXINTEGER"><code>LUA_MAXINTEGER</code></a>,
with the minimum and the maximum values that fit in this type.
<hr><h3><a name="lua_isboolean"><code>lua_isboolean</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_isboolean (lua_State *L, int index);</pre>
<p>
Returns 1 if the value at the given index is a boolean,
and 0 otherwise.
<hr><h3><a name="lua_iscfunction"><code>lua_iscfunction</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_iscfunction (lua_State *L, int index);</pre>
<p>
Returns 1 if the value at the given index is a C function,
and 0 otherwise.
<hr><h3><a name="lua_isfunction"><code>lua_isfunction</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_isfunction (lua_State *L, int index);</pre>
<p>
Returns 1 if the value at the given index is a function
(either C or Lua), and 0 otherwise.
<hr><h3><a name="lua_isinteger"><code>lua_isinteger</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_isinteger (lua_State *L, int index);</pre>
<p>
Returns 1 if the value at the given index is an integer
(that is, the value is a number and is represented as an integer),
and 0 otherwise.
<hr><h3><a name="lua_islightuserdata"><code>lua_islightuserdata</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_islightuserdata (lua_State *L, int index);</pre>
<p>
Returns 1 if the value at the given index is a light userdata,
and 0 otherwise.
<hr><h3><a name="lua_isnil"><code>lua_isnil</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_isnil (lua_State *L, int index);</pre>
<p>
Returns 1 if the value at the given index is <b>nil</b>,
and 0 otherwise.
<hr><h3><a name="lua_isnone"><code>lua_isnone</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_isnone (lua_State *L, int index);</pre>
<p>
Returns 1 if the given index is not valid,
and 0 otherwise.
<hr><h3><a name="lua_isnoneornil"><code>lua_isnoneornil</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_isnoneornil (lua_State *L, int index);</pre>
<p>
Returns 1 if the given index is not valid
or if the value at this index is <b>nil</b>,
and 0 otherwise.
<hr><h3><a name="lua_isnumber"><code>lua_isnumber</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_isnumber (lua_State *L, int index);</pre>
<p>
Returns 1 if the value at the given index is a number
or a string convertible to a number,
and 0 otherwise.
<hr><h3><a name="lua_isstring"><code>lua_isstring</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_isstring (lua_State *L, int index);</pre>
<p>
Returns 1 if the value at the given index is a string
or a number (which is always convertible to a string),
and 0 otherwise.
<hr><h3><a name="lua_istable"><code>lua_istable</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_istable (lua_State *L, int index);</pre>
<p>
Returns 1 if the value at the given index is a table,
and 0 otherwise.
<hr><h3><a name="lua_isthread"><code>lua_isthread</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_isthread (lua_State *L, int index);</pre>
<p>
Returns 1 if the value at the given index is a thread,
and 0 otherwise.
<hr><h3><a name="lua_isuserdata"><code>lua_isuserdata</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_isuserdata (lua_State *L, int index);</pre>
<p>
Returns 1 if the value at the given index is a userdata
(either full or light), and 0 otherwise.
<hr><h3><a name="lua_isyieldable"><code>lua_isyieldable</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_isyieldable (lua_State *L);</pre>
<p>
Returns 1 if the given coroutine can yield,
and 0 otherwise.
<hr><h3><a name="lua_KContext"><code>lua_KContext</code></a></h3>
<pre>typedef ... lua_KContext;</pre>
<p>
The type for continuation-function contexts.
It must be a numeric type.
This type is defined as <code>intptr_t</code>
when <code>intptr_t</code> is available,
so that it can store pointers too.
Otherwise, it is defined as <code>ptrdiff_t</code>.
<hr><h3><a name="lua_KFunction"><code>lua_KFunction</code></a></h3>
<pre>typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);</pre>
<p>
Type for continuation functions (see <a href="#4.5">§4.5</a>).
<hr><h3><a name="lua_len"><code>lua_len</code></a></h3><p>
<span class="apii">[-0, +1, <em>e</em>]</span>
<pre>void lua_len (lua_State *L, int index);</pre>
<p>
Returns the length of the value at the given index.
It is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.7">§3.4.7</a>) and
may trigger a metamethod for the "length" event (see <a href="#2.4">§2.4</a>).
The result is pushed on the stack.
<hr><h3><a name="lua_load"><code>lua_load</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>int lua_load (lua_State *L,
lua_Reader reader,
void *data,
const char *chunkname,
const char *mode);</pre>
<p>
Loads a Lua chunk without running it.
If there are no errors,
<code>lua_load</code> pushes the compiled chunk as a Lua
function on top of the stack.
Otherwise, it pushes an error message.
<p>
The <code>lua_load</code> function uses a user-supplied <code>reader</code> function
to read the chunk (see <a href="#lua_Reader"><code>lua_Reader</code></a>).
The <code>data</code> argument is an opaque value passed to the reader function.
<p>
The <code>chunkname</code> argument gives a name to the chunk,
which is used for error messages and in debug information (see <a href="#4.7">§4.7</a>).
<p>
<code>lua_load</code> automatically detects whether the chunk is text or binary
and loads it accordingly (see program <code>luac</code>).
The string <code>mode</code> works as in function <a href="#pdf-load"><code>load</code></a>,
with the addition that
a <code>NULL</code> value is equivalent to the string "<code>bt</code>".
<p>
<code>lua_load</code> uses the stack internally,
so the reader function must always leave the stack
unmodified when returning.
<p>
<code>lua_load</code> can return
<a href="#pdf-LUA_OK"><code>LUA_OK</code></a>, <a href="#pdf-LUA_ERRSYNTAX"><code>LUA_ERRSYNTAX</code></a>, or <a href="#pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>.
The function may also return other values corresponding to
errors raised by the read function (see <a href="#4.4.1">§4.4.1</a>).
<p>
If the resulting function has upvalues,
its first upvalue is set to the value of the global environment
stored at index <code>LUA_RIDX_GLOBALS</code> in the registry (see <a href="#4.3">§4.3</a>).
When loading main chunks,
this upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>).
Other upvalues are initialized with <b>nil</b>.
<hr><h3><a name="lua_newstate"><code>lua_newstate</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_State *lua_newstate (lua_Alloc f, void *ud);</pre>
<p>
Creates a new independent state and returns its main thread.
Returns <code>NULL</code> if it cannot create the state
(due to lack of memory).
The argument <code>f</code> is the allocator function;
Lua will do all memory allocation for this state
through this function (see <a href="#lua_Alloc"><code>lua_Alloc</code></a>).
The second argument, <code>ud</code>, is an opaque pointer that Lua
passes to the allocator in every call.
<hr><h3><a name="lua_newtable"><code>lua_newtable</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>void lua_newtable (lua_State *L);</pre>
<p>
Creates a new empty table and pushes it onto the stack.
It is equivalent to <code>lua_createtable(L, 0, 0)</code>.
<hr><h3><a name="lua_newthread"><code>lua_newthread</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>lua_State *lua_newthread (lua_State *L);</pre>
<p>
Creates a new thread, pushes it on the stack,
and returns a pointer to a <a href="#lua_State"><code>lua_State</code></a> that represents this new thread.
The new thread returned by this function shares with the original thread
its global environment,
but has an independent execution stack.
<p>
Threads are subject to garbage collection,
like any Lua object.
<hr><h3><a name="lua_newuserdatauv"><code>lua_newuserdatauv</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>void *lua_newuserdatauv (lua_State *L, size_t size, int nuvalue);</pre>
<p>
This function creates and pushes on the stack a new full userdata,
with <code>nuvalue</code> associated Lua values, called <code>user values</code>,
plus an associated block of raw memory with <code>size</code> bytes.
(The user values can be set and read with the functions
<a href="#lua_setiuservalue"><code>lua_setiuservalue</code></a> and <a href="#lua_getiuservalue"><code>lua_getiuservalue</code></a>.)
<p>
The function returns the address of the block of memory.
Lua ensures that this address is valid as long as
the corresponding userdata is alive (see <a href="#2.5">§2.5</a>).
Moreover, if the userdata is marked for finalization (see <a href="#2.5.3">§2.5.3</a>),
its address is valid at least until the call to its finalizer.
<hr><h3><a name="lua_next"><code>lua_next</code></a></h3><p>
<span class="apii">[-1, +(2|0), <em>v</em>]</span>
<pre>int lua_next (lua_State *L, int index);</pre>
<p>
Pops a key from the stack,
and pushes a key–value pair from the table at the given index,
the "next" pair after the given key.
If there are no more elements in the table,
then <a href="#lua_next"><code>lua_next</code></a> returns 0 and pushes nothing.
<p>
A typical table traversal looks like this:
<pre>
/* table is in the stack at index 't' */
lua_pushnil(L); /* first key */
while (lua_next(L, t) != 0) {
/* uses 'key' (at index -2) and 'value' (at index -1) */
printf("%s - %s\n",
lua_typename(L, lua_type(L, -2)),
lua_typename(L, lua_type(L, -1)));
/* removes 'value'; keeps 'key' for next iteration */
lua_pop(L, 1);
}
</pre>
<p>
While traversing a table,
avoid calling <a href="#lua_tolstring"><code>lua_tolstring</code></a> directly on a key,
unless you know that the key is actually a string.
Recall that <a href="#lua_tolstring"><code>lua_tolstring</code></a> may change
the value at the given index;
this confuses the next call to <a href="#lua_next"><code>lua_next</code></a>.
<p>
This function may raise an error if the given key
is neither <b>nil</b> nor present in the table.
See function <a href="#pdf-next"><code>next</code></a> for the caveats of modifying
the table during its traversal.
<hr><h3><a name="lua_Number"><code>lua_Number</code></a></h3>
<pre>typedef ... lua_Number;</pre>
<p>
The type of floats in Lua.
<p>
By default this type is double,
but that can be changed to a single float or a long double.
(See <code>LUA_FLOAT_TYPE</code> in <code>luaconf.h</code>.)
<hr><h3><a name="lua_numbertointeger"><code>lua_numbertointeger</code></a></h3>
<pre>int lua_numbertointeger (lua_Number n, lua_Integer *p);</pre>
<p>
Tries to convert a Lua float to a Lua integer;
the float <code>n</code> must have an integral value.
If that value is within the range of Lua integers,
it is converted to an integer and assigned to <code>*p</code>.
The macro results in a boolean indicating whether the
conversion was successful.
(Note that this range test can be tricky to do
correctly without this macro, due to rounding.)
<p>
This macro may evaluate its arguments more than once.
<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p>
<span class="apii">[-(nargs + 1), +(nresults|1), –]</span>
<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);</pre>
<p>
Calls a function (or a callable object) in protected mode.
<p>
Both <code>nargs</code> and <code>nresults</code> have the same meaning as
in <a href="#lua_call"><code>lua_call</code></a>.
If there are no errors during the call,
<a href="#lua_pcall"><code>lua_pcall</code></a> behaves exactly like <a href="#lua_call"><code>lua_call</code></a>.
However, if there is any error,
<a href="#lua_pcall"><code>lua_pcall</code></a> catches it,
pushes a single value on the stack (the error object),
and returns an error code.
Like <a href="#lua_call"><code>lua_call</code></a>,
<a href="#lua_pcall"><code>lua_pcall</code></a> always removes the function
and its arguments from the stack.
<p>
If <code>msgh</code> is 0,
then the error object returned on the stack
is exactly the original error object.
Otherwise, <code>msgh</code> is the stack index of a
<em>message handler</em>.
(This index cannot be a pseudo-index.)
In case of runtime errors,
this handler will be called with the error object
and its return value will be the object
returned on the stack by <a href="#lua_pcall"><code>lua_pcall</code></a>.
<p>
Typically, the message handler is used to add more debug
information to the error object, such as a stack traceback.
Such information cannot be gathered after the return of <a href="#lua_pcall"><code>lua_pcall</code></a>,
since by then the stack has unwound.
<p>
The <a href="#lua_pcall"><code>lua_pcall</code></a> function returns one of the following status codes:
<a href="#pdf-LUA_OK"><code>LUA_OK</code></a>, <a href="#pdf-LUA_ERRRUN"><code>LUA_ERRRUN</code></a>, <a href="#pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>, or <a href="#pdf-LUA_ERRERR"><code>LUA_ERRERR</code></a>.
<hr><h3><a name="lua_pcallk"><code>lua_pcallk</code></a></h3><p>
<span class="apii">[-(nargs + 1), +(nresults|1), –]</span>
<pre>int lua_pcallk (lua_State *L,
int nargs,
int nresults,
int msgh,
lua_KContext ctx,
lua_KFunction k);</pre>
<p>
This function behaves exactly like <a href="#lua_pcall"><code>lua_pcall</code></a>,
except that it allows the called function to yield (see <a href="#4.5">§4.5</a>).
<hr><h3><a name="lua_pop"><code>lua_pop</code></a></h3><p>
<span class="apii">[-n, +0, <em>e</em>]</span>
<pre>void lua_pop (lua_State *L, int n);</pre>
<p>
Pops <code>n</code> elements from the stack.
It is implemented as a macro over <a href="#lua_settop"><code>lua_settop</code></a>.
<hr><h3><a name="lua_pushboolean"><code>lua_pushboolean</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>void lua_pushboolean (lua_State *L, int b);</pre>
<p>
Pushes a boolean value with value <code>b</code> onto the stack.
<hr><h3><a name="lua_pushcclosure"><code>lua_pushcclosure</code></a></h3><p>
<span class="apii">[-n, +1, <em>m</em>]</span>
<pre>void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);</pre>
<p>
Pushes a new C closure onto the stack.
This function receives a pointer to a C function
and pushes onto the stack a Lua value of type <code>function</code> that,
when called, invokes the corresponding C function.
The parameter <code>n</code> tells how many upvalues this function will have
(see <a href="#4.2">§4.2</a>).
<p>
Any function to be callable by Lua must
follow the correct protocol to receive its parameters
and return its results (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
<p>
When a C function is created,
it is possible to associate some values with it,
the so called upvalues;
these upvalues are then accessible to the function whenever it is called.
This association is called a C closure (see <a href="#4.2">§4.2</a>).
To create a C closure,
first the initial values for its upvalues must be pushed onto the stack.
(When there are multiple upvalues, the first value is pushed first.)
Then <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>
is called to create and push the C function onto the stack,
with the argument <code>n</code> telling how many values will be
associated with the function.
<a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a> also pops these values from the stack.
<p>
The maximum value for <code>n</code> is 255.
<p>
When <code>n</code> is zero,
this function creates a <em>light C function</em>,
which is just a pointer to the C function.
In that case, it never raises a memory error.
<hr><h3><a name="lua_pushcfunction"><code>lua_pushcfunction</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>void lua_pushcfunction (lua_State *L, lua_CFunction f);</pre>
<p>
Pushes a C function onto the stack.
This function is equivalent to <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a> with no upvalues.
<hr><h3><a name="lua_pushfstring"><code>lua_pushfstring</code></a></h3><p>
<span class="apii">[-0, +1, <em>v</em>]</span>
<pre>const char *lua_pushfstring (lua_State *L, const char *fmt, ...);</pre>
<p>
Pushes onto the stack a formatted string
and returns a pointer to this string (see <a href="#4.1.3">§4.1.3</a>).
It is similar to the ISO C function <code>sprintf</code>,
but has two important differences.
First,
you do not have to allocate space for the result;
the result is a Lua string and Lua takes care of memory allocation
(and deallocation, through garbage collection).
Second,
the conversion specifiers are quite restricted.
There are no flags, widths, or precisions.
The conversion specifiers can only be
'<code>%%</code>' (inserts the character '<code>%</code>'),
'<code>%s</code>' (inserts a zero-terminated string, with no size restrictions),
'<code>%f</code>' (inserts a <a href="#lua_Number"><code>lua_Number</code></a>),
'<code>%I</code>' (inserts a <a href="#lua_Integer"><code>lua_Integer</code></a>),
'<code>%p</code>' (inserts a pointer),
'<code>%d</code>' (inserts an <code>int</code>),
'<code>%c</code>' (inserts an <code>int</code> as a one-byte character), and
'<code>%U</code>' (inserts a <code>long int</code> as a UTF-8 byte sequence).
<p>
This function may raise errors due to memory overflow
or an invalid conversion specifier.
<hr><h3><a name="lua_pushglobaltable"><code>lua_pushglobaltable</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>void lua_pushglobaltable (lua_State *L);</pre>
<p>
Pushes the global environment onto the stack.
<hr><h3><a name="lua_pushinteger"><code>lua_pushinteger</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>void lua_pushinteger (lua_State *L, lua_Integer n);</pre>
<p>
Pushes an integer with value <code>n</code> onto the stack.
<hr><h3><a name="lua_pushlightuserdata"><code>lua_pushlightuserdata</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>void lua_pushlightuserdata (lua_State *L, void *p);</pre>
<p>
Pushes a light userdata onto the stack.
<p>
Userdata represent C values in Lua.
A <em>light userdata</em> represents a pointer, a <code>void*</code>.
It is a value (like a number):
you do not create it, it has no individual metatable,
and it is not collected (as it was never created).
A light userdata is equal to "any"
light userdata with the same C address.
<hr><h3><a name="lua_pushliteral"><code>lua_pushliteral</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>const char *lua_pushliteral (lua_State *L, const char *s);</pre>
<p>
This macro is equivalent to <a href="#lua_pushstring"><code>lua_pushstring</code></a>,
but should be used only when <code>s</code> is a literal string.
(Lua may optimize this case.)
<hr><h3><a name="lua_pushlstring"><code>lua_pushlstring</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>const char *lua_pushlstring (lua_State *L, const char *s, size_t len);</pre>
<p>
Pushes the string pointed to by <code>s</code> with size <code>len</code>
onto the stack.
Lua will make or reuse an internal copy of the given string,
so the memory at <code>s</code> can be freed or reused immediately after
the function returns.
The string can contain any binary data,
including embedded zeros.
<p>
Returns a pointer to the internal copy of the string (see <a href="#4.1.3">§4.1.3</a>).
<hr><h3><a name="lua_pushnil"><code>lua_pushnil</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>void lua_pushnil (lua_State *L);</pre>
<p>
Pushes a nil value onto the stack.
<hr><h3><a name="lua_pushnumber"><code>lua_pushnumber</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>void lua_pushnumber (lua_State *L, lua_Number n);</pre>
<p>
Pushes a float with value <code>n</code> onto the stack.
<hr><h3><a name="lua_pushstring"><code>lua_pushstring</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>const char *lua_pushstring (lua_State *L, const char *s);</pre>
<p>
Pushes the zero-terminated string pointed to by <code>s</code>
onto the stack.
Lua will make or reuse an internal copy of the given string,
so the memory at <code>s</code> can be freed or reused immediately after
the function returns.
<p>
Returns a pointer to the internal copy of the string (see <a href="#4.1.3">§4.1.3</a>).
<p>
If <code>s</code> is <code>NULL</code>, pushes <b>nil</b> and returns <code>NULL</code>.
<hr><h3><a name="lua_pushthread"><code>lua_pushthread</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>int lua_pushthread (lua_State *L);</pre>
<p>
Pushes the thread represented by <code>L</code> onto the stack.
Returns 1 if this thread is the main thread of its state.
<hr><h3><a name="lua_pushvalue"><code>lua_pushvalue</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>void lua_pushvalue (lua_State *L, int index);</pre>
<p>
Pushes a copy of the element at the given index
onto the stack.
<hr><h3><a name="lua_pushvfstring"><code>lua_pushvfstring</code></a></h3><p>
<span class="apii">[-0, +1, <em>v</em>]</span>
<pre>const char *lua_pushvfstring (lua_State *L,
const char *fmt,
va_list argp);</pre>
<p>
Equivalent to <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>, except that it receives a <code>va_list</code>
instead of a variable number of arguments.
<hr><h3><a name="lua_rawequal"><code>lua_rawequal</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_rawequal (lua_State *L, int index1, int index2);</pre>
<p>
Returns 1 if the two values in indices <code>index1</code> and
<code>index2</code> are primitively equal
(that is, equal without calling the <code>__eq</code> metamethod).
Otherwise returns 0.
Also returns 0 if any of the indices are not valid.
<hr><h3><a name="lua_rawget"><code>lua_rawget</code></a></h3><p>
<span class="apii">[-1, +1, –]</span>
<pre>int lua_rawget (lua_State *L, int index);</pre>
<p>
Similar to <a href="#lua_gettable"><code>lua_gettable</code></a>, but does a raw access
(i.e., without metamethods).
<hr><h3><a name="lua_rawgeti"><code>lua_rawgeti</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>int lua_rawgeti (lua_State *L, int index, lua_Integer n);</pre>
<p>
Pushes onto the stack the value <code>t[n]</code>,
where <code>t</code> is the table at the given index.
The access is raw,
that is, it does not use the <code>__index</code> metavalue.
<p>
Returns the type of the pushed value.
<hr><h3><a name="lua_rawgetp"><code>lua_rawgetp</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>int lua_rawgetp (lua_State *L, int index, const void *p);</pre>
<p>
Pushes onto the stack the value <code>t[k]</code>,
where <code>t</code> is the table at the given index and
<code>k</code> is the pointer <code>p</code> represented as a light userdata.
The access is raw;
that is, it does not use the <code>__index</code> metavalue.
<p>
Returns the type of the pushed value.
<hr><h3><a name="lua_rawlen"><code>lua_rawlen</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_Unsigned lua_rawlen (lua_State *L, int index);</pre>
<p>
Returns the raw "length" of the value at the given index:
for strings, this is the string length;
for tables, this is the result of the length operator ('<code>#</code>')
with no metamethods;
for userdata, this is the size of the block of memory allocated
for the userdata.
For other values, this call returns 0.
<hr><h3><a name="lua_rawset"><code>lua_rawset</code></a></h3><p>
<span class="apii">[-2, +0, <em>m</em>]</span>
<pre>void lua_rawset (lua_State *L, int index);</pre>
<p>
Similar to <a href="#lua_settable"><code>lua_settable</code></a>, but does a raw assignment
(i.e., without metamethods).
<hr><h3><a name="lua_rawseti"><code>lua_rawseti</code></a></h3><p>
<span class="apii">[-1, +0, <em>m</em>]</span>
<pre>void lua_rawseti (lua_State *L, int index, lua_Integer i);</pre>
<p>
Does the equivalent of <code>t[i] = v</code>,
where <code>t</code> is the table at the given index
and <code>v</code> is the value on the top of the stack.
<p>
This function pops the value from the stack.
The assignment is raw,
that is, it does not use the <code>__newindex</code> metavalue.
<hr><h3><a name="lua_rawsetp"><code>lua_rawsetp</code></a></h3><p>
<span class="apii">[-1, +0, <em>m</em>]</span>
<pre>void lua_rawsetp (lua_State *L, int index, const void *p);</pre>
<p>
Does the equivalent of <code>t[p] = v</code>,
where <code>t</code> is the table at the given index,
<code>p</code> is encoded as a light userdata,
and <code>v</code> is the value on the top of the stack.
<p>
This function pops the value from the stack.
The assignment is raw,
that is, it does not use the <code>__newindex</code> metavalue.
<hr><h3><a name="lua_Reader"><code>lua_Reader</code></a></h3>
<pre>typedef const char * (*lua_Reader) (lua_State *L,
void *data,
size_t *size);</pre>
<p>
The reader function used by <a href="#lua_load"><code>lua_load</code></a>.
Every time <a href="#lua_load"><code>lua_load</code></a> needs another piece of the chunk,
it calls the reader,
passing along its <code>data</code> parameter.
The reader must return a pointer to a block of memory
with a new piece of the chunk
and set <code>size</code> to the block size.
The block must exist until the reader function is called again.
To signal the end of the chunk,
the reader must return <code>NULL</code> or set <code>size</code> to zero.
The reader function may return pieces of any size greater than zero.
<hr><h3><a name="lua_register"><code>lua_register</code></a></h3><p>
<span class="apii">[-0, +0, <em>e</em>]</span>
<pre>void lua_register (lua_State *L, const char *name, lua_CFunction f);</pre>
<p>
Sets the C function <code>f</code> as the new value of global <code>name</code>.
It is defined as a macro:
<pre>
#define lua_register(L,n,f) \
(lua_pushcfunction(L, f), lua_setglobal(L, n))
</pre>
<hr><h3><a name="lua_remove"><code>lua_remove</code></a></h3><p>
<span class="apii">[-1, +0, –]</span>
<pre>void lua_remove (lua_State *L, int index);</pre>
<p>
Removes the element at the given valid index,
shifting down the elements above this index to fill the gap.
This function cannot be called with a pseudo-index,
because a pseudo-index is not an actual stack position.
<hr><h3><a name="lua_replace"><code>lua_replace</code></a></h3><p>
<span class="apii">[-1, +0, –]</span>
<pre>void lua_replace (lua_State *L, int index);</pre>
<p>
Moves the top element into the given valid index
without shifting any element
(therefore replacing the value at that given index),
and then pops the top element.
<hr><h3><a name="lua_resetthread"><code>lua_resetthread</code></a></h3><p>
<span class="apii">[-0, +?, –]</span>
<pre>int lua_resetthread (lua_State *L);</pre>
<p>
Resets a thread, cleaning its call stack and closing all pending
to-be-closed variables.
Returns a status code:
<a href="#pdf-LUA_OK"><code>LUA_OK</code></a> for no errors in the thread
(either the original error that stopped the thread or
errors in closing methods),
or an error status otherwise.
In case of error,
leaves the error object on the top of the stack.
<hr><h3><a name="lua_resume"><code>lua_resume</code></a></h3><p>
<span class="apii">[-?, +?, –]</span>
<pre>int lua_resume (lua_State *L, lua_State *from, int nargs,
int *nresults);</pre>
<p>
Starts and resumes a coroutine in the given thread <code>L</code>.
<p>
To start a coroutine,
you push the main function plus any arguments
onto the empty stack of the thread.
then you call <a href="#lua_resume"><code>lua_resume</code></a>,
with <code>nargs</code> being the number of arguments.
This call returns when the coroutine suspends or finishes its execution.
When it returns,
<code>*nresults</code> is updated and
the top of the stack contains
the <code>*nresults</code> values passed to <a href="#lua_yield"><code>lua_yield</code></a>
or returned by the body function.
<a href="#lua_resume"><code>lua_resume</code></a> returns
<a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the coroutine yields,
<a href="#pdf-LUA_OK"><code>LUA_OK</code></a> if the coroutine finishes its execution
without errors,
or an error code in case of errors (see <a href="#4.4.1">§4.4.1</a>).
In case of errors,
the error object is on the top of the stack.
<p>
To resume a coroutine,
you remove the <code>*nresults</code> yielded values from its stack,
push the values to be passed as results from <code>yield</code>,
and then call <a href="#lua_resume"><code>lua_resume</code></a>.
<p>
The parameter <code>from</code> represents the coroutine that is resuming <code>L</code>.
If there is no such coroutine,
this parameter can be <code>NULL</code>.
<hr><h3><a name="lua_rotate"><code>lua_rotate</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void lua_rotate (lua_State *L, int idx, int n);</pre>
<p>
Rotates the stack elements between the valid index <code>idx</code>
and the top of the stack.
The elements are rotated <code>n</code> positions in the direction of the top,
for a positive <code>n</code>,
or <code>-n</code> positions in the direction of the bottom,
for a negative <code>n</code>.
The absolute value of <code>n</code> must not be greater than the size
of the slice being rotated.
This function cannot be called with a pseudo-index,
because a pseudo-index is not an actual stack position.
<hr><h3><a name="lua_setallocf"><code>lua_setallocf</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);</pre>
<p>
Changes the allocator function of a given state to <code>f</code>
with user data <code>ud</code>.
<hr><h3><a name="lua_setfield"><code>lua_setfield</code></a></h3><p>
<span class="apii">[-1, +0, <em>e</em>]</span>
<pre>void lua_setfield (lua_State *L, int index, const char *k);</pre>
<p>
Does the equivalent to <code>t[k] = v</code>,
where <code>t</code> is the value at the given index
and <code>v</code> is the value on the top of the stack.
<p>
This function pops the value from the stack.
As in Lua, this function may trigger a metamethod
for the "newindex" event (see <a href="#2.4">§2.4</a>).
<hr><h3><a name="lua_setglobal"><code>lua_setglobal</code></a></h3><p>
<span class="apii">[-1, +0, <em>e</em>]</span>
<pre>void lua_setglobal (lua_State *L, const char *name);</pre>
<p>
Pops a value from the stack and
sets it as the new value of global <code>name</code>.
<hr><h3><a name="lua_seti"><code>lua_seti</code></a></h3><p>
<span class="apii">[-1, +0, <em>e</em>]</span>
<pre>void lua_seti (lua_State *L, int index, lua_Integer n);</pre>
<p>
Does the equivalent to <code>t[n] = v</code>,
where <code>t</code> is the value at the given index
and <code>v</code> is the value on the top of the stack.
<p>
This function pops the value from the stack.
As in Lua, this function may trigger a metamethod
for the "newindex" event (see <a href="#2.4">§2.4</a>).
<hr><h3><a name="lua_setiuservalue"><code>lua_setiuservalue</code></a></h3><p>
<span class="apii">[-1, +0, –]</span>
<pre>int lua_setiuservalue (lua_State *L, int index, int n);</pre>
<p>
Pops a value from the stack and sets it as
the new <code>n</code>-th user value associated to the
full userdata at the given index.
Returns 0 if the userdata does not have that value.
<hr><h3><a name="lua_setmetatable"><code>lua_setmetatable</code></a></h3><p>
<span class="apii">[-1, +0, –]</span>
<pre>int lua_setmetatable (lua_State *L, int index);</pre>
<p>
Pops a table or <b>nil</b> from the stack and
sets that value as the new metatable for the value at the given index.
(<b>nil</b> means no metatable.)
<p>
(For historical reasons, this function returns an <code>int</code>,
which now is always 1.)
<hr><h3><a name="lua_settable"><code>lua_settable</code></a></h3><p>
<span class="apii">[-2, +0, <em>e</em>]</span>
<pre>void lua_settable (lua_State *L, int index);</pre>
<p>
Does the equivalent to <code>t[k] = v</code>,
where <code>t</code> is the value at the given index,
<code>v</code> is the value on the top of the stack,
and <code>k</code> is the value just below the top.
<p>
This function pops both the key and the value from the stack.
As in Lua, this function may trigger a metamethod
for the "newindex" event (see <a href="#2.4">§2.4</a>).
<hr><h3><a name="lua_settop"><code>lua_settop</code></a></h3><p>
<span class="apii">[-?, +?, <em>e</em>]</span>
<pre>void lua_settop (lua_State *L, int index);</pre>
<p>
Accepts any index, or 0,
and sets the stack top to this index.
If the new top is greater than the old one,
then the new elements are filled with <b>nil</b>.
If <code>index</code> is 0, then all stack elements are removed.
<p>
This function can run arbitrary code when removing an index
marked as to-be-closed from the stack.
<hr><h3><a name="lua_setwarnf"><code>lua_setwarnf</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void lua_setwarnf (lua_State *L, lua_WarnFunction f, void *ud);</pre>
<p>
Sets the warning function to be used by Lua to emit warnings
(see <a href="#lua_WarnFunction"><code>lua_WarnFunction</code></a>).
The <code>ud</code> parameter sets the value <code>ud</code> passed to
the warning function.
<hr><h3><a name="lua_State"><code>lua_State</code></a></h3>
<pre>typedef struct lua_State lua_State;</pre>
<p>
An opaque structure that points to a thread and indirectly
(through the thread) to the whole state of a Lua interpreter.
The Lua library is fully reentrant:
it has no global variables.
All information about a state is accessible through this structure.
<p>
A pointer to this structure must be passed as the first argument to
every function in the library, except to <a href="#lua_newstate"><code>lua_newstate</code></a>,
which creates a Lua state from scratch.
<hr><h3><a name="lua_status"><code>lua_status</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_status (lua_State *L);</pre>
<p>
Returns the status of the thread <code>L</code>.
<p>
The status can be <a href="#pdf-LUA_OK"><code>LUA_OK</code></a> for a normal thread,
an error code if the thread finished the execution
of a <a href="#lua_resume"><code>lua_resume</code></a> with an error,
or <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the thread is suspended.
<p>
You can call functions only in threads with status <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>.
You can resume threads with status <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>
(to start a new coroutine) or <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a>
(to resume a coroutine).
<hr><h3><a name="lua_stringtonumber"><code>lua_stringtonumber</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>size_t lua_stringtonumber (lua_State *L, const char *s);</pre>
<p>
Converts the zero-terminated string <code>s</code> to a number,
pushes that number into the stack,
and returns the total size of the string,
that is, its length plus one.
The conversion can result in an integer or a float,
according to the lexical conventions of Lua (see <a href="#3.1">§3.1</a>).
The string may have leading and trailing whitespaces and a sign.
If the string is not a valid numeral,
returns 0 and pushes nothing.
(Note that the result can be used as a boolean,
true if the conversion succeeds.)
<hr><h3><a name="lua_toboolean"><code>lua_toboolean</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_toboolean (lua_State *L, int index);</pre>
<p>
Converts the Lua value at the given index to a C boolean
value (0 or 1).
Like all tests in Lua,
<a href="#lua_toboolean"><code>lua_toboolean</code></a> returns true for any Lua value
different from <b>false</b> and <b>nil</b>;
otherwise it returns false.
(If you want to accept only actual boolean values,
use <a href="#lua_isboolean"><code>lua_isboolean</code></a> to test the value's type.)
<hr><h3><a name="lua_tocfunction"><code>lua_tocfunction</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_CFunction lua_tocfunction (lua_State *L, int index);</pre>
<p>
Converts a value at the given index to a C function.
That value must be a C function;
otherwise, returns <code>NULL</code>.
<hr><h3><a name="lua_toclose"><code>lua_toclose</code></a></h3><p>
<span class="apii">[-0, +0, <em>m</em>]</span>
<pre>void lua_toclose (lua_State *L, int index);</pre>
<p>
Marks the given index in the stack as a
to-be-closed slot (see <a href="#3.3.8">§3.3.8</a>).
Like a to-be-closed variable in Lua,
the value at that slot in the stack will be closed
when it goes out of scope.
Here, in the context of a C function,
to go out of scope means that the running function returns to Lua,
or there is an error,
or the slot is removed from the stack through
<a href="#lua_settop"><code>lua_settop</code></a> or <a href="#lua_pop"><code>lua_pop</code></a>,
or there is a call to <a href="#lua_closeslot"><code>lua_closeslot</code></a>.
A slot marked as to-be-closed should not be removed from the stack
by any other function in the API except <a href="#lua_settop"><code>lua_settop</code></a> or <a href="#lua_pop"><code>lua_pop</code></a>,
unless previously deactivated by <a href="#lua_closeslot"><code>lua_closeslot</code></a>.
<p>
This function should not be called for an index
that is equal to or below an active to-be-closed slot.
<p>
Note that, both in case of errors and of a regular return,
by the time the <code>__close</code> metamethod runs,
the C stack was already unwound,
so that any automatic C variable declared in the calling function
(e.g., a buffer) will be out of scope.
<hr><h3><a name="lua_tointeger"><code>lua_tointeger</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_Integer lua_tointeger (lua_State *L, int index);</pre>
<p>
Equivalent to <a href="#lua_tointegerx"><code>lua_tointegerx</code></a> with <code>isnum</code> equal to <code>NULL</code>.
<hr><h3><a name="lua_tointegerx"><code>lua_tointegerx</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_Integer lua_tointegerx (lua_State *L, int index, int *isnum);</pre>
<p>
Converts the Lua value at the given index
to the signed integral type <a href="#lua_Integer"><code>lua_Integer</code></a>.
The Lua value must be an integer,
or a number or string convertible to an integer (see <a href="#3.4.3">§3.4.3</a>);
otherwise, <code>lua_tointegerx</code> returns 0.
<p>
If <code>isnum</code> is not <code>NULL</code>,
its referent is assigned a boolean value that
indicates whether the operation succeeded.
<hr><h3><a name="lua_tolstring"><code>lua_tolstring</code></a></h3><p>
<span class="apii">[-0, +0, <em>m</em>]</span>
<pre>const char *lua_tolstring (lua_State *L, int index, size_t *len);</pre>
<p>
Converts the Lua value at the given index to a C string.
If <code>len</code> is not <code>NULL</code>,
it sets <code>*len</code> with the string length.
The Lua value must be a string or a number;
otherwise, the function returns <code>NULL</code>.
If the value is a number,
then <code>lua_tolstring</code> also
<em>changes the actual value in the stack to a string</em>.
(This change confuses <a href="#lua_next"><code>lua_next</code></a>
when <code>lua_tolstring</code> is applied to keys during a table traversal.)
<p>
<code>lua_tolstring</code> returns a pointer
to a string inside the Lua state (see <a href="#4.1.3">§4.1.3</a>).
This string always has a zero ('<code>\0</code>')
after its last character (as in C),
but can contain other zeros in its body.
<hr><h3><a name="lua_tonumber"><code>lua_tonumber</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_Number lua_tonumber (lua_State *L, int index);</pre>
<p>
Equivalent to <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> with <code>isnum</code> equal to <code>NULL</code>.
<hr><h3><a name="lua_tonumberx"><code>lua_tonumberx</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_Number lua_tonumberx (lua_State *L, int index, int *isnum);</pre>
<p>
Converts the Lua value at the given index
to the C type <a href="#lua_Number"><code>lua_Number</code></a> (see <a href="#lua_Number"><code>lua_Number</code></a>).
The Lua value must be a number or a string convertible to a number
(see <a href="#3.4.3">§3.4.3</a>);
otherwise, <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> returns 0.
<p>
If <code>isnum</code> is not <code>NULL</code>,
its referent is assigned a boolean value that
indicates whether the operation succeeded.
<hr><h3><a name="lua_topointer"><code>lua_topointer</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>const void *lua_topointer (lua_State *L, int index);</pre>
<p>
Converts the value at the given index to a generic
C pointer (<code>void*</code>).
The value can be a userdata, a table, a thread, a string, or a function;
otherwise, <code>lua_topointer</code> returns <code>NULL</code>.
Different objects will give different pointers.
There is no way to convert the pointer back to its original value.
<p>
Typically this function is used only for hashing and debug information.
<hr><h3><a name="lua_tostring"><code>lua_tostring</code></a></h3><p>
<span class="apii">[-0, +0, <em>m</em>]</span>
<pre>const char *lua_tostring (lua_State *L, int index);</pre>
<p>
Equivalent to <a href="#lua_tolstring"><code>lua_tolstring</code></a> with <code>len</code> equal to <code>NULL</code>.
<hr><h3><a name="lua_tothread"><code>lua_tothread</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_State *lua_tothread (lua_State *L, int index);</pre>
<p>
Converts the value at the given index to a Lua thread
(represented as <code>lua_State*</code>).
This value must be a thread;
otherwise, the function returns <code>NULL</code>.
<hr><h3><a name="lua_touserdata"><code>lua_touserdata</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void *lua_touserdata (lua_State *L, int index);</pre>
<p>
If the value at the given index is a full userdata,
returns its memory-block address.
If the value is a light userdata,
returns its value (a pointer).
Otherwise, returns <code>NULL</code>.
<hr><h3><a name="lua_type"><code>lua_type</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_type (lua_State *L, int index);</pre>
<p>
Returns the type of the value in the given valid index,
or <code>LUA_TNONE</code> for a non-valid but acceptable index.
The types returned by <a href="#lua_type"><code>lua_type</code></a> are coded by the following constants
defined in <code>lua.h</code>:
<a name="pdf-LUA_TNIL"><code>LUA_TNIL</code></a>,
<a name="pdf-LUA_TNUMBER"><code>LUA_TNUMBER</code></a>,
<a name="pdf-LUA_TBOOLEAN"><code>LUA_TBOOLEAN</code></a>,
<a name="pdf-LUA_TSTRING"><code>LUA_TSTRING</code></a>,
<a name="pdf-LUA_TTABLE"><code>LUA_TTABLE</code></a>,
<a name="pdf-LUA_TFUNCTION"><code>LUA_TFUNCTION</code></a>,
<a name="pdf-LUA_TUSERDATA"><code>LUA_TUSERDATA</code></a>,
<a name="pdf-LUA_TTHREAD"><code>LUA_TTHREAD</code></a>,
and
<a name="pdf-LUA_TLIGHTUSERDATA"><code>LUA_TLIGHTUSERDATA</code></a>.
<hr><h3><a name="lua_typename"><code>lua_typename</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>const char *lua_typename (lua_State *L, int tp);</pre>
<p>
Returns the name of the type encoded by the value <code>tp</code>,
which must be one the values returned by <a href="#lua_type"><code>lua_type</code></a>.
<hr><h3><a name="lua_Unsigned"><code>lua_Unsigned</code></a></h3>
<pre>typedef ... lua_Unsigned;</pre>
<p>
The unsigned version of <a href="#lua_Integer"><code>lua_Integer</code></a>.
<hr><h3><a name="lua_upvalueindex"><code>lua_upvalueindex</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_upvalueindex (int i);</pre>
<p>
Returns the pseudo-index that represents the <code>i</code>-th upvalue of
the running function (see <a href="#4.2">§4.2</a>).
<code>i</code> must be in the range <em>[1,256]</em>.
<hr><h3><a name="lua_version"><code>lua_version</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_Number lua_version (lua_State *L);</pre>
<p>
Returns the version number of this core.
<hr><h3><a name="lua_WarnFunction"><code>lua_WarnFunction</code></a></h3>
<pre>typedef void (*lua_WarnFunction) (void *ud, const char *msg, int tocont);</pre>
<p>
The type of warning functions, called by Lua to emit warnings.
The first parameter is an opaque pointer
set by <a href="#lua_setwarnf"><code>lua_setwarnf</code></a>.
The second parameter is the warning message.
The third parameter is a boolean that
indicates whether the message is
to be continued by the message in the next call.
<p>
See <a href="#pdf-warn"><code>warn</code></a> for more details about warnings.
<hr><h3><a name="lua_warning"><code>lua_warning</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void lua_warning (lua_State *L, const char *msg, int tocont);</pre>
<p>
Emits a warning with the given message.
A message in a call with <code>tocont</code> true should be
continued in another call to this function.
<p>
See <a href="#pdf-warn"><code>warn</code></a> for more details about warnings.
<hr><h3><a name="lua_Writer"><code>lua_Writer</code></a></h3>
<pre>typedef int (*lua_Writer) (lua_State *L,
const void* p,
size_t sz,
void* ud);</pre>
<p>
The type of the writer function used by <a href="#lua_dump"><code>lua_dump</code></a>.
Every time <a href="#lua_dump"><code>lua_dump</code></a> produces another piece of chunk,
it calls the writer,
passing along the buffer to be written (<code>p</code>),
its size (<code>sz</code>),
and the <code>ud</code> parameter supplied to <a href="#lua_dump"><code>lua_dump</code></a>.
<p>
The writer returns an error code:
0 means no errors;
any other value means an error and stops <a href="#lua_dump"><code>lua_dump</code></a> from
calling the writer again.
<hr><h3><a name="lua_xmove"><code>lua_xmove</code></a></h3><p>
<span class="apii">[-?, +?, –]</span>
<pre>void lua_xmove (lua_State *from, lua_State *to, int n);</pre>
<p>
Exchange values between different threads of the same state.
<p>
This function pops <code>n</code> values from the stack <code>from</code>,
and pushes them onto the stack <code>to</code>.
<hr><h3><a name="lua_yield"><code>lua_yield</code></a></h3><p>
<span class="apii">[-?, +?, <em>v</em>]</span>
<pre>int lua_yield (lua_State *L, int nresults);</pre>
<p>
This function is equivalent to <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
but it has no continuation (see <a href="#4.5">§4.5</a>).
Therefore, when the thread resumes,
it continues the function that called
the function calling <code>lua_yield</code>.
To avoid surprises,
this function should be called only in a tail call.
<hr><h3><a name="lua_yieldk"><code>lua_yieldk</code></a></h3><p>
<span class="apii">[-?, +?, <em>v</em>]</span>
<pre>int lua_yieldk (lua_State *L,
int nresults,
lua_KContext ctx,
lua_KFunction k);</pre>
<p>
Yields a coroutine (thread).
<p>
When a C function calls <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
the running coroutine suspends its execution,
and the call to <a href="#lua_resume"><code>lua_resume</code></a> that started this coroutine returns.
The parameter <code>nresults</code> is the number of values from the stack
that will be passed as results to <a href="#lua_resume"><code>lua_resume</code></a>.
<p>
When the coroutine is resumed again,
Lua calls the given continuation function <code>k</code> to continue
the execution of the C function that yielded (see <a href="#4.5">§4.5</a>).
This continuation function receives the same stack
from the previous function,
with the <code>n</code> results removed and
replaced by the arguments passed to <a href="#lua_resume"><code>lua_resume</code></a>.
Moreover,
the continuation function receives the value <code>ctx</code>
that was passed to <a href="#lua_yieldk"><code>lua_yieldk</code></a>.
<p>
Usually, this function does not return;
when the coroutine eventually resumes,
it continues executing the continuation function.
However, there is one special case,
which is when this function is called
from inside a line or a count hook (see <a href="#4.7">§4.7</a>).
In that case, <code>lua_yieldk</code> should be called with no continuation
(probably in the form of <a href="#lua_yield"><code>lua_yield</code></a>) and no results,
and the hook should return immediately after the call.
Lua will yield and,
when the coroutine resumes again,
it will continue the normal execution
of the (Lua) function that triggered the hook.
<p>
This function can raise an error if it is called from a thread
with a pending C call with no continuation function
(what is called a <em>C-call boundary</em>),
or it is called from a thread that is not running inside a resume
(typically the main thread).
<h2>4.7 – <a name="4.7">The Debug Interface</a></h2>
<p>
Lua has no built-in debugging facilities.
Instead, it offers a special interface
by means of functions and <em>hooks</em>.
This interface allows the construction of different
kinds of debuggers, profilers, and other tools
that need "inside information" from the interpreter.
<hr><h3><a name="lua_Debug"><code>lua_Debug</code></a></h3>
<pre>typedef struct lua_Debug {
int event;
const char *name; /* (n) */
const char *namewhat; /* (n) */
const char *what; /* (S) */
const char *source; /* (S) */
size_t srclen; /* (S) */
int currentline; /* (l) */
int linedefined; /* (S) */
int lastlinedefined; /* (S) */
unsigned char nups; /* (u) number of upvalues */
unsigned char nparams; /* (u) number of parameters */
char isvararg; /* (u) */
char istailcall; /* (t) */
unsigned short ftransfer; /* (r) index of first value transferred */
unsigned short ntransfer; /* (r) number of transferred values */
char short_src[LUA_IDSIZE]; /* (S) */
/* private part */
<em>other fields</em>
} lua_Debug;</pre>
<p>
A structure used to carry different pieces of
information about a function or an activation record.
<a href="#lua_getstack"><code>lua_getstack</code></a> fills only the private part
of this structure, for later use.
To fill the other fields of <a href="#lua_Debug"><code>lua_Debug</code></a> with useful information,
you must call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
<p>
The fields of <a href="#lua_Debug"><code>lua_Debug</code></a> have the following meaning:
<ul>
<li><b><code>source</code>: </b>
the source of the chunk that created the function.
If <code>source</code> starts with a '<code>@</code>',
it means that the function was defined in a file where
the file name follows the '<code>@</code>'.
If <code>source</code> starts with a '<code>=</code>',
the remainder of its contents describes the source in a user-dependent manner.
Otherwise,
the function was defined in a string where
<code>source</code> is that string.
</li>
<li><b><code>srclen</code>: </b>
The length of the string <code>source</code>.
</li>
<li><b><code>short_src</code>: </b>
a "printable" version of <code>source</code>, to be used in error messages.
</li>
<li><b><code>linedefined</code>: </b>
the line number where the definition of the function starts.
</li>
<li><b><code>lastlinedefined</code>: </b>
the line number where the definition of the function ends.
</li>
<li><b><code>what</code>: </b>
the string <code>"Lua"</code> if the function is a Lua function,
<code>"C"</code> if it is a C function,
<code>"main"</code> if it is the main part of a chunk.
</li>
<li><b><code>currentline</code>: </b>
the current line where the given function is executing.
When no line information is available,
<code>currentline</code> is set to -1.
</li>
<li><b><code>name</code>: </b>
a reasonable name for the given function.
Because functions in Lua are first-class values,
they do not have a fixed name:
some functions can be the value of multiple global variables,
while others can be stored only in a table field.
The <code>lua_getinfo</code> function checks how the function was
called to find a suitable name.
If it cannot find a name,
then <code>name</code> is set to <code>NULL</code>.
</li>
<li><b><code>namewhat</code>: </b>
explains the <code>name</code> field.
The value of <code>namewhat</code> can be
<code>"global"</code>, <code>"local"</code>, <code>"method"</code>,
<code>"field"</code>, <code>"upvalue"</code>, or <code>""</code> (the empty string),
according to how the function was called.
(Lua uses the empty string when no other option seems to apply.)
</li>
<li><b><code>istailcall</code>: </b>
true if this function invocation was called by a tail call.
In this case, the caller of this level is not in the stack.
</li>
<li><b><code>nups</code>: </b>
the number of upvalues of the function.
</li>
<li><b><code>nparams</code>: </b>
the number of parameters of the function
(always 0 for C functions).
</li>
<li><b><code>isvararg</code>: </b>
true if the function is a vararg function
(always true for C functions).
</li>
<li><b><code>ftransfer</code>: </b>
the index in the stack of the first value being "transferred",
that is, parameters in a call or return values in a return.
(The other values are in consecutive indices.)
Using this index, you can access and modify these values
through <a href="#lua_getlocal"><code>lua_getlocal</code></a> and <a href="#lua_setlocal"><code>lua_setlocal</code></a>.
This field is only meaningful during a
call hook, denoting the first parameter,
or a return hook, denoting the first value being returned.
(For call hooks, this value is always 1.)
</li>
<li><b><code>ntransfer</code>: </b>
The number of values being transferred (see previous item).
(For calls of Lua functions,
this value is always equal to <code>nparams</code>.)
</li>
</ul>
<hr><h3><a name="lua_gethook"><code>lua_gethook</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_Hook lua_gethook (lua_State *L);</pre>
<p>
Returns the current hook function.
<hr><h3><a name="lua_gethookcount"><code>lua_gethookcount</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_gethookcount (lua_State *L);</pre>
<p>
Returns the current hook count.
<hr><h3><a name="lua_gethookmask"><code>lua_gethookmask</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_gethookmask (lua_State *L);</pre>
<p>
Returns the current hook mask.
<hr><h3><a name="lua_getinfo"><code>lua_getinfo</code></a></h3><p>
<span class="apii">[-(0|1), +(0|1|2), <em>m</em>]</span>
<pre>int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);</pre>
<p>
Gets information about a specific function or function invocation.
<p>
To get information about a function invocation,
the parameter <code>ar</code> must be a valid activation record that was
filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or
given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
<p>
To get information about a function, you push it onto the stack
and start the <code>what</code> string with the character '<code>></code>'.
(In that case,
<code>lua_getinfo</code> pops the function from the top of the stack.)
For instance, to know in which line a function <code>f</code> was defined,
you can write the following code:
<pre>
lua_Debug ar;
lua_getglobal(L, "f"); /* get global 'f' */
lua_getinfo(L, ">S", &ar);
printf("%d\n", ar.linedefined);
</pre>
<p>
Each character in the string <code>what</code>
selects some fields of the structure <code>ar</code> to be filled or
a value to be pushed on the stack:
<ul>
<li><b>'<code>n</code>': </b> fills in the field <code>name</code> and <code>namewhat</code>;
</li>
<li><b>'<code>S</code>': </b>
fills in the fields <code>source</code>, <code>short_src</code>,
<code>linedefined</code>, <code>lastlinedefined</code>, and <code>what</code>;
</li>
<li><b>'<code>l</code>': </b> fills in the field <code>currentline</code>;
</li>
<li><b>'<code>t</code>': </b> fills in the field <code>istailcall</code>;
</li>
<li><b>'<code>u</code>': </b> fills in the fields
<code>nups</code>, <code>nparams</code>, and <code>isvararg</code>;
</li>
<li><b>'<code>f</code>': </b>
pushes onto the stack the function that is
running at the given level;
</li>
<li><b>'<code>L</code>': </b>
pushes onto the stack a table whose indices are the
numbers of the lines that are valid on the function.
(A <em>valid line</em> is a line with some associated code,
that is, a line where you can put a break point.
Non-valid lines include empty lines and comments.)
<p>
If this option is given together with option '<code>f</code>',
its table is pushed after the function.
<p>
This is the only option that can raise a memory error.
</li>
</ul>
<p>
This function returns 0 to signal an invalid option in <code>what</code>;
even then the valid options are handled correctly.
<hr><h3><a name="lua_getlocal"><code>lua_getlocal</code></a></h3><p>
<span class="apii">[-0, +(0|1), –]</span>
<pre>const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);</pre>
<p>
Gets information about a local variable or a temporary value
of a given activation record or a given function.
<p>
In the first case,
the parameter <code>ar</code> must be a valid activation record that was
filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or
given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
The index <code>n</code> selects which local variable to inspect;
see <a href="#pdf-debug.getlocal"><code>debug.getlocal</code></a> for details about variable indices
and names.
<p>
<a href="#lua_getlocal"><code>lua_getlocal</code></a> pushes the variable's value onto the stack
and returns its name.
<p>
In the second case, <code>ar</code> must be <code>NULL</code> and the function
to be inspected must be on the top of the stack.
In this case, only parameters of Lua functions are visible
(as there is no information about what variables are active)
and no values are pushed onto the stack.
<p>
Returns <code>NULL</code> (and pushes nothing)
when the index is greater than
the number of active local variables.
<hr><h3><a name="lua_getstack"><code>lua_getstack</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>int lua_getstack (lua_State *L, int level, lua_Debug *ar);</pre>
<p>
Gets information about the interpreter runtime stack.
<p>
This function fills parts of a <a href="#lua_Debug"><code>lua_Debug</code></a> structure with
an identification of the <em>activation record</em>
of the function executing at a given level.
Level 0 is the current running function,
whereas level <em>n+1</em> is the function that has called level <em>n</em>
(except for tail calls, which do not count in the stack).
When called with a level greater than the stack depth,
<a href="#lua_getstack"><code>lua_getstack</code></a> returns 0;
otherwise it returns 1.
<hr><h3><a name="lua_getupvalue"><code>lua_getupvalue</code></a></h3><p>
<span class="apii">[-0, +(0|1), –]</span>
<pre>const char *lua_getupvalue (lua_State *L, int funcindex, int n);</pre>
<p>
Gets information about the <code>n</code>-th upvalue
of the closure at index <code>funcindex</code>.
It pushes the upvalue's value onto the stack
and returns its name.
Returns <code>NULL</code> (and pushes nothing)
when the index <code>n</code> is greater than the number of upvalues.
<p>
See <a href="#pdf-debug.getupvalue"><code>debug.getupvalue</code></a> for more information about upvalues.
<hr><h3><a name="lua_Hook"><code>lua_Hook</code></a></h3>
<pre>typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);</pre>
<p>
Type for debugging hook functions.
<p>
Whenever a hook is called, its <code>ar</code> argument has its field
<code>event</code> set to the specific event that triggered the hook.
Lua identifies these events with the following constants:
<a name="pdf-LUA_HOOKCALL"><code>LUA_HOOKCALL</code></a>, <a name="pdf-LUA_HOOKRET"><code>LUA_HOOKRET</code></a>,
<a name="pdf-LUA_HOOKTAILCALL"><code>LUA_HOOKTAILCALL</code></a>, <a name="pdf-LUA_HOOKLINE"><code>LUA_HOOKLINE</code></a>,
and <a name="pdf-LUA_HOOKCOUNT"><code>LUA_HOOKCOUNT</code></a>.
Moreover, for line events, the field <code>currentline</code> is also set.
To get the value of any other field in <code>ar</code>,
the hook must call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
<p>
For call events, <code>event</code> can be <code>LUA_HOOKCALL</code>,
the normal value, or <code>LUA_HOOKTAILCALL</code>, for a tail call;
in this case, there will be no corresponding return event.
<p>
While Lua is running a hook, it disables other calls to hooks.
Therefore, if a hook calls back Lua to execute a function or a chunk,
this execution occurs without any calls to hooks.
<p>
Hook functions cannot have continuations,
that is, they cannot call <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
<a href="#lua_pcallk"><code>lua_pcallk</code></a>, or <a href="#lua_callk"><code>lua_callk</code></a> with a non-null <code>k</code>.
<p>
Hook functions can yield under the following conditions:
Only count and line events can yield;
to yield, a hook function must finish its execution
calling <a href="#lua_yield"><code>lua_yield</code></a> with <code>nresults</code> equal to zero
(that is, with no values).
<hr><h3><a name="lua_sethook"><code>lua_sethook</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void lua_sethook (lua_State *L, lua_Hook f, int mask, int count);</pre>
<p>
Sets the debugging hook function.
<p>
Argument <code>f</code> is the hook function.
<code>mask</code> specifies on which events the hook will be called:
it is formed by a bitwise OR of the constants
<a name="pdf-LUA_MASKCALL"><code>LUA_MASKCALL</code></a>,
<a name="pdf-LUA_MASKRET"><code>LUA_MASKRET</code></a>,
<a name="pdf-LUA_MASKLINE"><code>LUA_MASKLINE</code></a>,
and <a name="pdf-LUA_MASKCOUNT"><code>LUA_MASKCOUNT</code></a>.
The <code>count</code> argument is only meaningful when the mask
includes <code>LUA_MASKCOUNT</code>.
For each event, the hook is called as explained below:
<ul>
<li><b>The call hook: </b> is called when the interpreter calls a function.
The hook is called just after Lua enters the new function.
</li>
<li><b>The return hook: </b> is called when the interpreter returns from a function.
The hook is called just before Lua leaves the function.
</li>
<li><b>The line hook: </b> is called when the interpreter is about to
start the execution of a new line of code,
or when it jumps back in the code (even to the same line).
This event only happens while Lua is executing a Lua function.
</li>
<li><b>The count hook: </b> is called after the interpreter executes every
<code>count</code> instructions.
This event only happens while Lua is executing a Lua function.
</li>
</ul>
<p>
Hooks are disabled by setting <code>mask</code> to zero.
<hr><h3><a name="lua_setlocal"><code>lua_setlocal</code></a></h3><p>
<span class="apii">[-(0|1), +0, –]</span>
<pre>const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);</pre>
<p>
Sets the value of a local variable of a given activation record.
It assigns the value on the top of the stack
to the variable and returns its name.
It also pops the value from the stack.
<p>
Returns <code>NULL</code> (and pops nothing)
when the index is greater than
the number of active local variables.
<p>
Parameters <code>ar</code> and <code>n</code> are as in the function <a href="#lua_getlocal"><code>lua_getlocal</code></a>.
<hr><h3><a name="lua_setupvalue"><code>lua_setupvalue</code></a></h3><p>
<span class="apii">[-(0|1), +0, –]</span>
<pre>const char *lua_setupvalue (lua_State *L, int funcindex, int n);</pre>
<p>
Sets the value of a closure's upvalue.
It assigns the value on the top of the stack
to the upvalue and returns its name.
It also pops the value from the stack.
<p>
Returns <code>NULL</code> (and pops nothing)
when the index <code>n</code> is greater than the number of upvalues.
<p>
Parameters <code>funcindex</code> and <code>n</code> are as in
the function <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>.
<hr><h3><a name="lua_upvalueid"><code>lua_upvalueid</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void *lua_upvalueid (lua_State *L, int funcindex, int n);</pre>
<p>
Returns a unique identifier for the upvalue numbered <code>n</code>
from the closure at index <code>funcindex</code>.
<p>
These unique identifiers allow a program to check whether different
closures share upvalues.
Lua closures that share an upvalue
(that is, that access a same external local variable)
will return identical ids for those upvalue indices.
<p>
Parameters <code>funcindex</code> and <code>n</code> are as in
the function <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>,
but <code>n</code> cannot be greater than the number of upvalues.
<hr><h3><a name="lua_upvaluejoin"><code>lua_upvaluejoin</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void lua_upvaluejoin (lua_State *L, int funcindex1, int n1,
int funcindex2, int n2);</pre>
<p>
Make the <code>n1</code>-th upvalue of the Lua closure at index <code>funcindex1</code>
refer to the <code>n2</code>-th upvalue of the Lua closure at index <code>funcindex2</code>.
<h1>5 – <a name="5">The Auxiliary Library</a></h1>
<p>
The <em>auxiliary library</em> provides several convenient functions
to interface C with Lua.
While the basic API provides the primitive functions for all
interactions between C and Lua,
the auxiliary library provides higher-level functions for some
common tasks.
<p>
All functions and types from the auxiliary library
are defined in header file <code>lauxlib.h</code> and
have a prefix <code>luaL_</code>.
<p>
All functions in the auxiliary library are built on
top of the basic API,
and so they provide nothing that cannot be done with that API.
Nevertheless, the use of the auxiliary library ensures
more consistency to your code.
<p>
Several functions in the auxiliary library use internally some
extra stack slots.
When a function in the auxiliary library uses less than five slots,
it does not check the stack size;
it simply assumes that there are enough slots.
<p>
Several functions in the auxiliary library are used to
check C function arguments.
Because the error message is formatted for arguments
(e.g., "<code>bad argument #1</code>"),
you should not use these functions for other stack values.
<p>
Functions called <code>luaL_check*</code>
always raise an error if the check is not satisfied.
<h2>5.1 – <a name="5.1">Functions and Types</a></h2>
<p>
Here we list all functions and types from the auxiliary library
in alphabetical order.
<hr><h3><a name="luaL_addchar"><code>luaL_addchar</code></a></h3><p>
<span class="apii">[-?, +?, <em>m</em>]</span>
<pre>void luaL_addchar (luaL_Buffer *B, char c);</pre>
<p>
Adds the byte <code>c</code> to the buffer <code>B</code>
(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
<hr><h3><a name="luaL_addgsub"><code>luaL_addgsub</code></a></h3><p>
<span class="apii">[-0, +0, <em>m</em>]</span>
<pre>const void luaL_addgsub (luaL_Buffer *B, const char *s,
const char *p, const char *r);</pre>
<p>
Adds a copy of the string <code>s</code> to the buffer <code>B</code> (see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>),
replacing any occurrence of the string <code>p</code>
with the string <code>r</code>.
<hr><h3><a name="luaL_addlstring"><code>luaL_addlstring</code></a></h3><p>
<span class="apii">[-?, +?, <em>m</em>]</span>
<pre>void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);</pre>
<p>
Adds the string pointed to by <code>s</code> with length <code>l</code> to
the buffer <code>B</code>
(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
The string can contain embedded zeros.
<hr><h3><a name="luaL_addsize"><code>luaL_addsize</code></a></h3><p>
<span class="apii">[-?, +?, –]</span>
<pre>void luaL_addsize (luaL_Buffer *B, size_t n);</pre>
<p>
Adds to the buffer <code>B</code>
a string of length <code>n</code> previously copied to the
buffer area (see <a href="#luaL_prepbuffer"><code>luaL_prepbuffer</code></a>).
<hr><h3><a name="luaL_addstring"><code>luaL_addstring</code></a></h3><p>
<span class="apii">[-?, +?, <em>m</em>]</span>
<pre>void luaL_addstring (luaL_Buffer *B, const char *s);</pre>
<p>
Adds the zero-terminated string pointed to by <code>s</code>
to the buffer <code>B</code>
(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
<hr><h3><a name="luaL_addvalue"><code>luaL_addvalue</code></a></h3><p>
<span class="apii">[-1, +?, <em>m</em>]</span>
<pre>void luaL_addvalue (luaL_Buffer *B);</pre>
<p>
Adds the value on the top of the stack
to the buffer <code>B</code>
(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
Pops the value.
<p>
This is the only function on string buffers that can (and must)
be called with an extra element on the stack,
which is the value to be added to the buffer.
<hr><h3><a name="luaL_argcheck"><code>luaL_argcheck</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>void luaL_argcheck (lua_State *L,
int cond,
int arg,
const char *extramsg);</pre>
<p>
Checks whether <code>cond</code> is true.
If it is not, raises an error with a standard message (see <a href="#luaL_argerror"><code>luaL_argerror</code></a>).
<hr><h3><a name="luaL_argerror"><code>luaL_argerror</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>int luaL_argerror (lua_State *L, int arg, const char *extramsg);</pre>
<p>
Raises an error reporting a problem with argument <code>arg</code>
of the C function that called it,
using a standard message
that includes <code>extramsg</code> as a comment:
<pre>
bad argument #<em>arg</em> to '<em>funcname</em>' (<em>extramsg</em>)
</pre><p>
This function never returns.
<hr><h3><a name="luaL_argexpected"><code>luaL_argexpected</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>void luaL_argexpected (lua_State *L,
int cond,
int arg,
const char *tname);</pre>
<p>
Checks whether <code>cond</code> is true.
If it is not, raises an error about the type of the argument <code>arg</code>
with a standard message (see <a href="#luaL_typeerror"><code>luaL_typeerror</code></a>).
<hr><h3><a name="luaL_Buffer"><code>luaL_Buffer</code></a></h3>
<pre>typedef struct luaL_Buffer luaL_Buffer;</pre>
<p>
Type for a <em>string buffer</em>.
<p>
A string buffer allows C code to build Lua strings piecemeal.
Its pattern of use is as follows:
<ul>
<li>First declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>
<li>Then initialize it with a call <code>luaL_buffinit(L, &b)</code>.</li>
<li>
Then add string pieces to the buffer calling any of
the <code>luaL_add*</code> functions.
</li>
<li>
Finish by calling <code>luaL_pushresult(&b)</code>.
This call leaves the final string on the top of the stack.
</li>
</ul>
<p>
If you know beforehand the maximum size of the resulting string,
you can use the buffer like this:
<ul>
<li>First declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>
<li>Then initialize it and preallocate a space of
size <code>sz</code> with a call <code>luaL_buffinitsize(L, &b, sz)</code>.</li>
<li>Then produce the string into that space.</li>
<li>
Finish by calling <code>luaL_pushresultsize(&b, sz)</code>,
where <code>sz</code> is the total size of the resulting string
copied into that space (which may be less than or
equal to the preallocated size).
</li>
</ul>
<p>
During its normal operation,
a string buffer uses a variable number of stack slots.
So, while using a buffer, you cannot assume that you know where
the top of the stack is.
You can use the stack between successive calls to buffer operations
as long as that use is balanced;
that is,
when you call a buffer operation,
the stack is at the same level
it was immediately after the previous buffer operation.
(The only exception to this rule is <a href="#luaL_addvalue"><code>luaL_addvalue</code></a>.)
After calling <a href="#luaL_pushresult"><code>luaL_pushresult</code></a>,
the stack is back to its level when the buffer was initialized,
plus the final string on its top.
<hr><h3><a name="luaL_buffaddr"><code>luaL_buffaddr</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>char *luaL_buffaddr (luaL_Buffer *B);</pre>
<p>
Returns the address of the current content of buffer <code>B</code>
(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
Note that any addition to the buffer may invalidate this address.
<hr><h3><a name="luaL_buffinit"><code>luaL_buffinit</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void luaL_buffinit (lua_State *L, luaL_Buffer *B);</pre>
<p>
Initializes a buffer <code>B</code>
(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
This function does not allocate any space;
the buffer must be declared as a variable.
<hr><h3><a name="luaL_bufflen"><code>luaL_bufflen</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>size_t luaL_bufflen (luaL_Buffer *B);</pre>
<p>
Returns the length of the current content of buffer <code>B</code>
(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
<hr><h3><a name="luaL_buffinitsize"><code>luaL_buffinitsize</code></a></h3><p>
<span class="apii">[-?, +?, <em>m</em>]</span>
<pre>char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz);</pre>
<p>
Equivalent to the sequence
<a href="#luaL_buffinit"><code>luaL_buffinit</code></a>, <a href="#luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a>.
<hr><h3><a name="luaL_buffsub"><code>luaL_buffsub</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void luaL_buffsub (luaL_Buffer *B, int n);</pre>
<p>
Removes <code>n</code> bytes from the the buffer <code>B</code>
(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
The buffer must have at least that many bytes.
<hr><h3><a name="luaL_callmeta"><code>luaL_callmeta</code></a></h3><p>
<span class="apii">[-0, +(0|1), <em>e</em>]</span>
<pre>int luaL_callmeta (lua_State *L, int obj, const char *e);</pre>
<p>
Calls a metamethod.
<p>
If the object at index <code>obj</code> has a metatable and this
metatable has a field <code>e</code>,
this function calls this field passing the object as its only argument.
In this case this function returns true and pushes onto the
stack the value returned by the call.
If there is no metatable or no metamethod,
this function returns false without pushing any value on the stack.
<hr><h3><a name="luaL_checkany"><code>luaL_checkany</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>void luaL_checkany (lua_State *L, int arg);</pre>
<p>
Checks whether the function has an argument
of any type (including <b>nil</b>) at position <code>arg</code>.
<hr><h3><a name="luaL_checkinteger"><code>luaL_checkinteger</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>lua_Integer luaL_checkinteger (lua_State *L, int arg);</pre>
<p>
Checks whether the function argument <code>arg</code> is an integer
(or can be converted to an integer)
and returns this integer.
<hr><h3><a name="luaL_checklstring"><code>luaL_checklstring</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>const char *luaL_checklstring (lua_State *L, int arg, size_t *l);</pre>
<p>
Checks whether the function argument <code>arg</code> is a string
and returns this string;
if <code>l</code> is not <code>NULL</code> fills its referent
with the string's length.
<p>
This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
so all conversions and caveats of that function apply here.
<hr><h3><a name="luaL_checknumber"><code>luaL_checknumber</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>lua_Number luaL_checknumber (lua_State *L, int arg);</pre>
<p>
Checks whether the function argument <code>arg</code> is a number
and returns this number converted to a <code>lua_Number</code>.
<hr><h3><a name="luaL_checkoption"><code>luaL_checkoption</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>int luaL_checkoption (lua_State *L,
int arg,
const char *def,
const char *const lst[]);</pre>
<p>
Checks whether the function argument <code>arg</code> is a string and
searches for this string in the array <code>lst</code>
(which must be NULL-terminated).
Returns the index in the array where the string was found.
Raises an error if the argument is not a string or
if the string cannot be found.
<p>
If <code>def</code> is not <code>NULL</code>,
the function uses <code>def</code> as a default value when
there is no argument <code>arg</code> or when this argument is <b>nil</b>.
<p>
This is a useful function for mapping strings to C enums.
(The usual convention in Lua libraries is
to use strings instead of numbers to select options.)
<hr><h3><a name="luaL_checkstack"><code>luaL_checkstack</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>void luaL_checkstack (lua_State *L, int sz, const char *msg);</pre>
<p>
Grows the stack size to <code>top + sz</code> elements,
raising an error if the stack cannot grow to that size.
<code>msg</code> is an additional text to go into the error message
(or <code>NULL</code> for no additional text).
<hr><h3><a name="luaL_checkstring"><code>luaL_checkstring</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>const char *luaL_checkstring (lua_State *L, int arg);</pre>
<p>
Checks whether the function argument <code>arg</code> is a string
and returns this string.
<p>
This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
so all conversions and caveats of that function apply here.
<hr><h3><a name="luaL_checktype"><code>luaL_checktype</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>void luaL_checktype (lua_State *L, int arg, int t);</pre>
<p>
Checks whether the function argument <code>arg</code> has type <code>t</code>.
See <a href="#lua_type"><code>lua_type</code></a> for the encoding of types for <code>t</code>.
<hr><h3><a name="luaL_checkudata"><code>luaL_checkudata</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>void *luaL_checkudata (lua_State *L, int arg, const char *tname);</pre>
<p>
Checks whether the function argument <code>arg</code> is a userdata
of the type <code>tname</code> (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>) and
returns the userdata's memory-block address (see <a href="#lua_touserdata"><code>lua_touserdata</code></a>).
<hr><h3><a name="luaL_checkversion"><code>luaL_checkversion</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>void luaL_checkversion (lua_State *L);</pre>
<p>
Checks whether the code making the call and the Lua library being called
are using the same version of Lua and the same numeric types.
<hr><h3><a name="luaL_dofile"><code>luaL_dofile</code></a></h3><p>
<span class="apii">[-0, +?, <em>m</em>]</span>
<pre>int luaL_dofile (lua_State *L, const char *filename);</pre>
<p>
Loads and runs the given file.
It is defined as the following macro:
<pre>
(luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))
</pre><p>
It returns <a href="#pdf-LUA_OK"><code>LUA_OK</code></a> if there are no errors,
or an error code in case of errors (see <a href="#4.4.1">§4.4.1</a>).
<hr><h3><a name="luaL_dostring"><code>luaL_dostring</code></a></h3><p>
<span class="apii">[-0, +?, –]</span>
<pre>int luaL_dostring (lua_State *L, const char *str);</pre>
<p>
Loads and runs the given string.
It is defined as the following macro:
<pre>
(luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))
</pre><p>
It returns <a href="#pdf-LUA_OK"><code>LUA_OK</code></a> if there are no errors,
or an error code in case of errors (see <a href="#4.4.1">§4.4.1</a>).
<hr><h3><a name="luaL_error"><code>luaL_error</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>int luaL_error (lua_State *L, const char *fmt, ...);</pre>
<p>
Raises an error.
The error message format is given by <code>fmt</code>
plus any extra arguments,
following the same rules of <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>.
It also adds at the beginning of the message the file name and
the line number where the error occurred,
if this information is available.
<p>
This function never returns,
but it is an idiom to use it in C functions
as <code>return luaL_error(<em>args</em>)</code>.
<hr><h3><a name="luaL_execresult"><code>luaL_execresult</code></a></h3><p>
<span class="apii">[-0, +3, <em>m</em>]</span>
<pre>int luaL_execresult (lua_State *L, int stat);</pre>
<p>
This function produces the return values for
process-related functions in the standard library
(<a href="#pdf-os.execute"><code>os.execute</code></a> and <a href="#pdf-io.close"><code>io.close</code></a>).
<hr><h3><a name="luaL_fileresult"><code>luaL_fileresult</code></a></h3><p>
<span class="apii">[-0, +(1|3), <em>m</em>]</span>
<pre>int luaL_fileresult (lua_State *L, int stat, const char *fname);</pre>
<p>
This function produces the return values for
file-related functions in the standard library
(<a href="#pdf-io.open"><code>io.open</code></a>, <a href="#pdf-os.rename"><code>os.rename</code></a>, <a href="#pdf-file:seek"><code>file:seek</code></a>, etc.).
<hr><h3><a name="luaL_getmetafield"><code>luaL_getmetafield</code></a></h3><p>
<span class="apii">[-0, +(0|1), <em>m</em>]</span>
<pre>int luaL_getmetafield (lua_State *L, int obj, const char *e);</pre>
<p>
Pushes onto the stack the field <code>e</code> from the metatable
of the object at index <code>obj</code> and returns the type of the pushed value.
If the object does not have a metatable,
or if the metatable does not have this field,
pushes nothing and returns <code>LUA_TNIL</code>.
<hr><h3><a name="luaL_getmetatable"><code>luaL_getmetatable</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>int luaL_getmetatable (lua_State *L, const char *tname);</pre>
<p>
Pushes onto the stack the metatable associated with the name <code>tname</code>
in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>),
or <b>nil</b> if there is no metatable associated with that name.
Returns the type of the pushed value.
<hr><h3><a name="luaL_getsubtable"><code>luaL_getsubtable</code></a></h3><p>
<span class="apii">[-0, +1, <em>e</em>]</span>
<pre>int luaL_getsubtable (lua_State *L, int idx, const char *fname);</pre>
<p>
Ensures that the value <code>t[fname]</code>,
where <code>t</code> is the value at index <code>idx</code>,
is a table,
and pushes that table onto the stack.
Returns true if it finds a previous table there
and false if it creates a new table.
<hr><h3><a name="luaL_gsub"><code>luaL_gsub</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>const char *luaL_gsub (lua_State *L,
const char *s,
const char *p,
const char *r);</pre>
<p>
Creates a copy of string <code>s</code>,
replacing any occurrence of the string <code>p</code>
with the string <code>r</code>.
Pushes the resulting string on the stack and returns it.
<hr><h3><a name="luaL_len"><code>luaL_len</code></a></h3><p>
<span class="apii">[-0, +0, <em>e</em>]</span>
<pre>lua_Integer luaL_len (lua_State *L, int index);</pre>
<p>
Returns the "length" of the value at the given index
as a number;
it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.7">§3.4.7</a>).
Raises an error if the result of the operation is not an integer.
(This case can only happen through metamethods.)
<hr><h3><a name="luaL_loadbuffer"><code>luaL_loadbuffer</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>int luaL_loadbuffer (lua_State *L,
const char *buff,
size_t sz,
const char *name);</pre>
<p>
Equivalent to <a href="#luaL_loadbufferx"><code>luaL_loadbufferx</code></a> with <code>mode</code> equal to <code>NULL</code>.
<hr><h3><a name="luaL_loadbufferx"><code>luaL_loadbufferx</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>int luaL_loadbufferx (lua_State *L,
const char *buff,
size_t sz,
const char *name,
const char *mode);</pre>
<p>
Loads a buffer as a Lua chunk.
This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the
buffer pointed to by <code>buff</code> with size <code>sz</code>.
<p>
This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>.
<code>name</code> is the chunk name,
used for debug information and error messages.
The string <code>mode</code> works as in the function <a href="#lua_load"><code>lua_load</code></a>.
<hr><h3><a name="luaL_loadfile"><code>luaL_loadfile</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>int luaL_loadfile (lua_State *L, const char *filename);</pre>
<p>
Equivalent to <a href="#luaL_loadfilex"><code>luaL_loadfilex</code></a> with <code>mode</code> equal to <code>NULL</code>.
<hr><h3><a name="luaL_loadfilex"><code>luaL_loadfilex</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>int luaL_loadfilex (lua_State *L, const char *filename,
const char *mode);</pre>
<p>
Loads a file as a Lua chunk.
This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the file
named <code>filename</code>.
If <code>filename</code> is <code>NULL</code>,
then it loads from the standard input.
The first line in the file is ignored if it starts with a <code>#</code>.
<p>
The string <code>mode</code> works as in the function <a href="#lua_load"><code>lua_load</code></a>.
<p>
This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>
or <a href="#pdf-LUA_ERRFILE"><code>LUA_ERRFILE</code></a> for file-related errors.
<p>
As <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk;
it does not run it.
<hr><h3><a name="luaL_loadstring"><code>luaL_loadstring</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>int luaL_loadstring (lua_State *L, const char *s);</pre>
<p>
Loads a string as a Lua chunk.
This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in
the zero-terminated string <code>s</code>.
<p>
This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>.
<p>
Also as <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk;
it does not run it.
<hr><h3><a name="luaL_newlib"><code>luaL_newlib</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>void luaL_newlib (lua_State *L, const luaL_Reg l[]);</pre>
<p>
Creates a new table and registers there
the functions in the list <code>l</code>.
<p>
It is implemented as the following macro:
<pre>
(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
</pre><p>
The array <code>l</code> must be the actual array,
not a pointer to it.
<hr><h3><a name="luaL_newlibtable"><code>luaL_newlibtable</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);</pre>
<p>
Creates a new table with a size optimized
to store all entries in the array <code>l</code>
(but does not actually store them).
It is intended to be used in conjunction with <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a>
(see <a href="#luaL_newlib"><code>luaL_newlib</code></a>).
<p>
It is implemented as a macro.
The array <code>l</code> must be the actual array,
not a pointer to it.
<hr><h3><a name="luaL_newmetatable"><code>luaL_newmetatable</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>int luaL_newmetatable (lua_State *L, const char *tname);</pre>
<p>
If the registry already has the key <code>tname</code>,
returns 0.
Otherwise,
creates a new table to be used as a metatable for userdata,
adds to this new table the pair <code>__name = tname</code>,
adds to the registry the pair <code>[tname] = new table</code>,
and returns 1.
<p>
In both cases,
the function pushes onto the stack the final value associated
with <code>tname</code> in the registry.
<hr><h3><a name="luaL_newstate"><code>luaL_newstate</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>lua_State *luaL_newstate (void);</pre>
<p>
Creates a new Lua state.
It calls <a href="#lua_newstate"><code>lua_newstate</code></a> with an
allocator based on the standard C allocation functions
and then sets a warning function and a panic function (see <a href="#4.4">§4.4</a>)
that print messages to the standard error output.
<p>
Returns the new state,
or <code>NULL</code> if there is a memory allocation error.
<hr><h3><a name="luaL_openlibs"><code>luaL_openlibs</code></a></h3><p>
<span class="apii">[-0, +0, <em>e</em>]</span>
<pre>void luaL_openlibs (lua_State *L);</pre>
<p>
Opens all standard Lua libraries into the given state.
<hr><h3><a name="luaL_opt"><code>luaL_opt</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>T luaL_opt (L, func, arg, dflt);</pre>
<p>
This macro is defined as follows:
<pre>
(lua_isnoneornil(L,(arg)) ? (dflt) : func(L,(arg)))
</pre><p>
In words, if the argument <code>arg</code> is nil or absent,
the macro results in the default <code>dflt</code>.
Otherwise, it results in the result of calling <code>func</code>
with the state <code>L</code> and the argument index <code>arg</code> as
arguments.
Note that it evaluates the expression <code>dflt</code> only if needed.
<hr><h3><a name="luaL_optinteger"><code>luaL_optinteger</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>lua_Integer luaL_optinteger (lua_State *L,
int arg,
lua_Integer d);</pre>
<p>
If the function argument <code>arg</code> is an integer
(or it is convertible to an integer),
returns this integer.
If this argument is absent or is <b>nil</b>,
returns <code>d</code>.
Otherwise, raises an error.
<hr><h3><a name="luaL_optlstring"><code>luaL_optlstring</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>const char *luaL_optlstring (lua_State *L,
int arg,
const char *d,
size_t *l);</pre>
<p>
If the function argument <code>arg</code> is a string,
returns this string.
If this argument is absent or is <b>nil</b>,
returns <code>d</code>.
Otherwise, raises an error.
<p>
If <code>l</code> is not <code>NULL</code>,
fills its referent with the result's length.
If the result is <code>NULL</code>
(only possible when returning <code>d</code> and <code>d == NULL</code>),
its length is considered zero.
<p>
This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
so all conversions and caveats of that function apply here.
<hr><h3><a name="luaL_optnumber"><code>luaL_optnumber</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number d);</pre>
<p>
If the function argument <code>arg</code> is a number,
returns this number as a <code>lua_Number</code>.
If this argument is absent or is <b>nil</b>,
returns <code>d</code>.
Otherwise, raises an error.
<hr><h3><a name="luaL_optstring"><code>luaL_optstring</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>const char *luaL_optstring (lua_State *L,
int arg,
const char *d);</pre>
<p>
If the function argument <code>arg</code> is a string,
returns this string.
If this argument is absent or is <b>nil</b>,
returns <code>d</code>.
Otherwise, raises an error.
<hr><h3><a name="luaL_prepbuffer"><code>luaL_prepbuffer</code></a></h3><p>
<span class="apii">[-?, +?, <em>m</em>]</span>
<pre>char *luaL_prepbuffer (luaL_Buffer *B);</pre>
<p>
Equivalent to <a href="#luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a>
with the predefined size <a name="pdf-LUAL_BUFFERSIZE"><code>LUAL_BUFFERSIZE</code></a>.
<hr><h3><a name="luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a></h3><p>
<span class="apii">[-?, +?, <em>m</em>]</span>
<pre>char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz);</pre>
<p>
Returns an address to a space of size <code>sz</code>
where you can copy a string to be added to buffer <code>B</code>
(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
After copying the string into this space you must call
<a href="#luaL_addsize"><code>luaL_addsize</code></a> with the size of the string to actually add
it to the buffer.
<hr><h3><a name="luaL_pushfail"><code>luaL_pushfail</code></a></h3><p>
<span class="apii">[-0, +1, –]</span>
<pre>void luaL_pushfail (lua_State *L);</pre>
<p>
Pushes the <b>fail</b> value onto the stack (see <a href="#6">§6</a>).
<hr><h3><a name="luaL_pushresult"><code>luaL_pushresult</code></a></h3><p>
<span class="apii">[-?, +1, <em>m</em>]</span>
<pre>void luaL_pushresult (luaL_Buffer *B);</pre>
<p>
Finishes the use of buffer <code>B</code> leaving the final string on
the top of the stack.
<hr><h3><a name="luaL_pushresultsize"><code>luaL_pushresultsize</code></a></h3><p>
<span class="apii">[-?, +1, <em>m</em>]</span>
<pre>void luaL_pushresultsize (luaL_Buffer *B, size_t sz);</pre>
<p>
Equivalent to the sequence <a href="#luaL_addsize"><code>luaL_addsize</code></a>, <a href="#luaL_pushresult"><code>luaL_pushresult</code></a>.
<hr><h3><a name="luaL_ref"><code>luaL_ref</code></a></h3><p>
<span class="apii">[-1, +0, <em>m</em>]</span>
<pre>int luaL_ref (lua_State *L, int t);</pre>
<p>
Creates and returns a <em>reference</em>,
in the table at index <code>t</code>,
for the object on the top of the stack (and pops the object).
<p>
A reference is a unique integer key.
As long as you do not manually add integer keys into the table <code>t</code>,
<a href="#luaL_ref"><code>luaL_ref</code></a> ensures the uniqueness of the key it returns.
You can retrieve an object referred by the reference <code>r</code>
by calling <code>lua_rawgeti(L, t, r)</code>.
The function <a href="#luaL_unref"><code>luaL_unref</code></a> frees a reference.
<p>
If the object on the top of the stack is <b>nil</b>,
<a href="#luaL_ref"><code>luaL_ref</code></a> returns the constant <a name="pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>.
The constant <a name="pdf-LUA_NOREF"><code>LUA_NOREF</code></a> is guaranteed to be different
from any reference returned by <a href="#luaL_ref"><code>luaL_ref</code></a>.
<hr><h3><a name="luaL_Reg"><code>luaL_Reg</code></a></h3>
<pre>typedef struct luaL_Reg {
const char *name;
lua_CFunction func;
} luaL_Reg;</pre>
<p>
Type for arrays of functions to be registered by
<a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a>.
<code>name</code> is the function name and <code>func</code> is a pointer to
the function.
Any array of <a href="#luaL_Reg"><code>luaL_Reg</code></a> must end with a sentinel entry
in which both <code>name</code> and <code>func</code> are <code>NULL</code>.
<hr><h3><a name="luaL_requiref"><code>luaL_requiref</code></a></h3><p>
<span class="apii">[-0, +1, <em>e</em>]</span>
<pre>void luaL_requiref (lua_State *L, const char *modname,
lua_CFunction openf, int glb);</pre>
<p>
If <code>package.loaded[modname]</code> is not true,
calls the function <code>openf</code> with the string <code>modname</code> as an argument
and sets the call result to <code>package.loaded[modname]</code>,
as if that function has been called through <a href="#pdf-require"><code>require</code></a>.
<p>
If <code>glb</code> is true,
also stores the module into the global <code>modname</code>.
<p>
Leaves a copy of the module on the stack.
<hr><h3><a name="luaL_setfuncs"><code>luaL_setfuncs</code></a></h3><p>
<span class="apii">[-nup, +0, <em>m</em>]</span>
<pre>void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup);</pre>
<p>
Registers all functions in the array <code>l</code>
(see <a href="#luaL_Reg"><code>luaL_Reg</code></a>) into the table on the top of the stack
(below optional upvalues, see next).
<p>
When <code>nup</code> is not zero,
all functions are created with <code>nup</code> upvalues,
initialized with copies of the <code>nup</code> values
previously pushed on the stack
on top of the library table.
These values are popped from the stack after the registration.
<hr><h3><a name="luaL_setmetatable"><code>luaL_setmetatable</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void luaL_setmetatable (lua_State *L, const char *tname);</pre>
<p>
Sets the metatable of the object on the top of the stack
as the metatable associated with name <code>tname</code>
in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
<hr><h3><a name="luaL_Stream"><code>luaL_Stream</code></a></h3>
<pre>typedef struct luaL_Stream {
FILE *f;
lua_CFunction closef;
} luaL_Stream;</pre>
<p>
The standard representation for file handles
used by the standard I/O library.
<p>
A file handle is implemented as a full userdata,
with a metatable called <code>LUA_FILEHANDLE</code>
(where <code>LUA_FILEHANDLE</code> is a macro with the actual metatable's name).
The metatable is created by the I/O library
(see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
<p>
This userdata must start with the structure <code>luaL_Stream</code>;
it can contain other data after this initial structure.
The field <code>f</code> points to the corresponding C stream
(or it can be <code>NULL</code> to indicate an incompletely created handle).
The field <code>closef</code> points to a Lua function
that will be called to close the stream
when the handle is closed or collected;
this function receives the file handle as its sole argument and
must return either a true value, in case of success,
or a false value plus an error message, in case of error.
Once Lua calls this field,
it changes the field value to <code>NULL</code>
to signal that the handle is closed.
<hr><h3><a name="luaL_testudata"><code>luaL_testudata</code></a></h3><p>
<span class="apii">[-0, +0, <em>m</em>]</span>
<pre>void *luaL_testudata (lua_State *L, int arg, const char *tname);</pre>
<p>
This function works like <a href="#luaL_checkudata"><code>luaL_checkudata</code></a>,
except that, when the test fails,
it returns <code>NULL</code> instead of raising an error.
<hr><h3><a name="luaL_tolstring"><code>luaL_tolstring</code></a></h3><p>
<span class="apii">[-0, +1, <em>e</em>]</span>
<pre>const char *luaL_tolstring (lua_State *L, int idx, size_t *len);</pre>
<p>
Converts any Lua value at the given index to a C string
in a reasonable format.
The resulting string is pushed onto the stack and also
returned by the function (see <a href="#4.1.3">§4.1.3</a>).
If <code>len</code> is not <code>NULL</code>,
the function also sets <code>*len</code> with the string length.
<p>
If the value has a metatable with a <code>__tostring</code> field,
then <code>luaL_tolstring</code> calls the corresponding metamethod
with the value as argument,
and uses the result of the call as its result.
<hr><h3><a name="luaL_traceback"><code>luaL_traceback</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>void luaL_traceback (lua_State *L, lua_State *L1, const char *msg,
int level);</pre>
<p>
Creates and pushes a traceback of the stack <code>L1</code>.
If <code>msg</code> is not <code>NULL</code>, it is appended
at the beginning of the traceback.
The <code>level</code> parameter tells at which level
to start the traceback.
<hr><h3><a name="luaL_typeerror"><code>luaL_typeerror</code></a></h3><p>
<span class="apii">[-0, +0, <em>v</em>]</span>
<pre>const char *luaL_typeerror (lua_State *L,
int arg,
const char *tname);</pre>
<p>
Raises a type error for the argument <code>arg</code>
of the C function that called it,
using a standard message;
<code>tname</code> is a "name" for the expected type.
This function never returns.
<hr><h3><a name="luaL_typename"><code>luaL_typename</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>const char *luaL_typename (lua_State *L, int index);</pre>
<p>
Returns the name of the type of the value at the given index.
<hr><h3><a name="luaL_unref"><code>luaL_unref</code></a></h3><p>
<span class="apii">[-0, +0, –]</span>
<pre>void luaL_unref (lua_State *L, int t, int ref);</pre>
<p>
Releases the reference <code>ref</code> from the table at index <code>t</code>
(see <a href="#luaL_ref"><code>luaL_ref</code></a>).
The entry is removed from the table,
so that the referred object can be collected.
The reference <code>ref</code> is also freed to be used again.
<p>
If <code>ref</code> is <a href="#pdf-LUA_NOREF"><code>LUA_NOREF</code></a> or <a href="#pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>,
<a href="#luaL_unref"><code>luaL_unref</code></a> does nothing.
<hr><h3><a name="luaL_where"><code>luaL_where</code></a></h3><p>
<span class="apii">[-0, +1, <em>m</em>]</span>
<pre>void luaL_where (lua_State *L, int lvl);</pre>
<p>
Pushes onto the stack a string identifying the current position
of the control at level <code>lvl</code> in the call stack.
Typically this string has the following format:
<pre>
<em>chunkname</em>:<em>currentline</em>:
</pre><p>
Level 0 is the running function,
level 1 is the function that called the running function,
etc.
<p>
This function is used to build a prefix for error messages.
<h1>6 – <a name="6">The Standard Libraries</a></h1>
<p>
The standard Lua libraries provide useful functions
that are implemented in C through the C API.
Some of these functions provide essential services to the language
(e.g., <a href="#pdf-type"><code>type</code></a> and <a href="#pdf-getmetatable"><code>getmetatable</code></a>);
others provide access to outside services (e.g., I/O);
and others could be implemented in Lua itself,
but that for different reasons
deserve an implementation in C (e.g., <a href="#pdf-table.sort"><code>table.sort</code></a>).
<p>
All libraries are implemented through the official C API
and are provided as separate C modules.
Unless otherwise noted,
these library functions do not adjust its number of arguments
to its expected parameters.
For instance, a function documented as <code>foo(arg)</code>
should not be called without an argument.
<p>
The notation <b>fail</b> means a false value representing
some kind of failure.
(Currently, <b>fail</b> is equal to <b>nil</b>,
but that may change in future versions.
The recommendation is to always test the success of these functions
with <code>(not status)</code>, instead of <code>(status == nil)</code>.)
<p>
Currently, Lua has the following standard libraries:
<ul>
<li>basic library (<a href="#6.1">§6.1</a>);</li>
<li>coroutine library (<a href="#6.2">§6.2</a>);</li>
<li>package library (<a href="#6.3">§6.3</a>);</li>
<li>string manipulation (<a href="#6.4">§6.4</a>);</li>
<li>basic UTF-8 support (<a href="#6.5">§6.5</a>);</li>
<li>table manipulation (<a href="#6.6">§6.6</a>);</li>
<li>mathematical functions (<a href="#6.7">§6.7</a>) (sin, log, etc.);</li>
<li>input and output (<a href="#6.8">§6.8</a>);</li>
<li>operating system facilities (<a href="#6.9">§6.9</a>);</li>
<li>debug facilities (<a href="#6.10">§6.10</a>).</li>
</ul><p>
Except for the basic and the package libraries,
each library provides all its functions as fields of a global table
or as methods of its objects.
<p>
To have access to these libraries,
the C host program should call the <a href="#luaL_openlibs"><code>luaL_openlibs</code></a> function,
which opens all standard libraries.
Alternatively,
the host program can open them individually by using
<a href="#luaL_requiref"><code>luaL_requiref</code></a> to call
<a name="pdf-luaopen_base"><code>luaopen_base</code></a> (for the basic library),
<a name="pdf-luaopen_package"><code>luaopen_package</code></a> (for the package library),
<a name="pdf-luaopen_coroutine"><code>luaopen_coroutine</code></a> (for the coroutine library),
<a name="pdf-luaopen_string"><code>luaopen_string</code></a> (for the string library),
<a name="pdf-luaopen_utf8"><code>luaopen_utf8</code></a> (for the UTF-8 library),
<a name="pdf-luaopen_table"><code>luaopen_table</code></a> (for the table library),
<a name="pdf-luaopen_math"><code>luaopen_math</code></a> (for the mathematical library),
<a name="pdf-luaopen_io"><code>luaopen_io</code></a> (for the I/O library),
<a name="pdf-luaopen_os"><code>luaopen_os</code></a> (for the operating system library),
and <a name="pdf-luaopen_debug"><code>luaopen_debug</code></a> (for the debug library).
These functions are declared in <a name="pdf-lualib.h"><code>lualib.h</code></a>.
<h2>6.1 – <a name="6.1">Basic Functions</a></h2>
<p>
The basic library provides core functions to Lua.
If you do not include this library in your application,
you should check carefully whether you need to provide
implementations for some of its facilities.
<p>
<hr><h3><a name="pdf-assert"><code>assert (v [, message])</code></a></h3>
<p>
Raises an error if
the value of its argument <code>v</code> is false (i.e., <b>nil</b> or <b>false</b>);
otherwise, returns all its arguments.
In case of error,
<code>message</code> is the error object;
when absent, it defaults to "<code>assertion failed!</code>"
<p>
<hr><h3><a name="pdf-collectgarbage"><code>collectgarbage ([opt [, arg]])</code></a></h3>
<p>
This function is a generic interface to the garbage collector.
It performs different functions according to its first argument, <code>opt</code>:
<ul>
<li><b>"<code>collect</code>": </b>
Performs a full garbage-collection cycle.
This is the default option.
</li>
<li><b>"<code>stop</code>": </b>
Stops automatic execution of the garbage collector.
The collector will run only when explicitly invoked,
until a call to restart it.
</li>
<li><b>"<code>restart</code>": </b>
Restarts automatic execution of the garbage collector.
</li>
<li><b>"<code>count</code>": </b>
Returns the total memory in use by Lua in Kbytes.
The value has a fractional part,
so that it multiplied by 1024
gives the exact number of bytes in use by Lua.
</li>
<li><b>"<code>step</code>": </b>
Performs a garbage-collection step.
The step "size" is controlled by <code>arg</code>.
With a zero value,
the collector will perform one basic (indivisible) step.
For non-zero values,
the collector will perform as if that amount of memory
(in Kbytes) had been allocated by Lua.
Returns <b>true</b> if the step finished a collection cycle.
</li>
<li><b>"<code>isrunning</code>": </b>
Returns a boolean that tells whether the collector is running
(i.e., not stopped).
</li>
<li><b>"<code>incremental</code>": </b>
Change the collector mode to incremental.
This option can be followed by three numbers:
the garbage-collector pause,
the step multiplier,
and the step size (see <a href="#2.5.1">§2.5.1</a>).
A zero means to not change that value.
</li>
<li><b>"<code>generational</code>": </b>
Change the collector mode to generational.
This option can be followed by two numbers:
the garbage-collector minor multiplier
and the major multiplier (see <a href="#2.5.2">§2.5.2</a>).
A zero means to not change that value.
</li>
</ul><p>
See <a href="#2.5">§2.5</a> for more details about garbage collection
and some of these options.
<p>
<hr><h3><a name="pdf-dofile"><code>dofile ([filename])</code></a></h3>
Opens the named file and executes its content as a Lua chunk.
When called without arguments,
<code>dofile</code> executes the content of the standard input (<code>stdin</code>).
Returns all values returned by the chunk.
In case of errors, <code>dofile</code> propagates the error
to its caller.
(That is, <code>dofile</code> does not run in protected mode.)
<p>
<hr><h3><a name="pdf-error"><code>error (message [, level])</code></a></h3>
Raises an error (see <a href="#2.3">§2.3</a>) with @{message} as the error object.
This function never returns.
<p>
Usually, <code>error</code> adds some information about the error position
at the beginning of the message, if the message is a string.
The <code>level</code> argument specifies how to get the error position.
With level 1 (the default), the error position is where the
<code>error</code> function was called.
Level 2 points the error to where the function
that called <code>error</code> was called; and so on.
Passing a level 0 avoids the addition of error position information
to the message.
<p>
<hr><h3><a name="pdf-_G"><code>_G</code></a></h3>
A global variable (not a function) that
holds the global environment (see <a href="#2.2">§2.2</a>).
Lua itself does not use this variable;
changing its value does not affect any environment,
nor vice versa.
<p>
<hr><h3><a name="pdf-getmetatable"><code>getmetatable (object)</code></a></h3>
<p>
If <code>object</code> does not have a metatable, returns <b>nil</b>.
Otherwise,
if the object's metatable has a <code>__metatable</code> field,
returns the associated value.
Otherwise, returns the metatable of the given object.
<p>
<hr><h3><a name="pdf-ipairs"><code>ipairs (t)</code></a></h3>
<p>
Returns three values (an iterator function, the table <code>t</code>, and 0)
so that the construction
<pre>
for i,v in ipairs(t) do <em>body</em> end
</pre><p>
will iterate over the key–value pairs
(<code>1,t[1]</code>), (<code>2,t[2]</code>), ...,
up to the first absent index.
<p>
<hr><h3><a name="pdf-load"><code>load (chunk [, chunkname [, mode [, env]]])</code></a></h3>
<p>
Loads a chunk.
<p>
If <code>chunk</code> is a string, the chunk is this string.
If <code>chunk</code> is a function,
<code>load</code> calls it repeatedly to get the chunk pieces.
Each call to <code>chunk</code> must return a string that concatenates
with previous results.
A return of an empty string, <b>nil</b>, or no value signals the end of the chunk.
<p>
If there are no syntactic errors,
<code>load</code> returns the compiled chunk as a function;
otherwise, it returns <b>fail</b> plus the error message.
<p>
When you load a main chunk,
the resulting function will always have exactly one upvalue,
the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>).
However,
when you load a binary chunk created from a function (see <a href="#pdf-string.dump"><code>string.dump</code></a>),
the resulting function can have an arbitrary number of upvalues,
and there is no guarantee that its first upvalue will be
the <code>_ENV</code> variable.
(A non-main function may not even have an <code>_ENV</code> upvalue.)
<p>
Regardless, if the resulting function has any upvalues,
its first upvalue is set to the value of <code>env</code>,
if that parameter is given,
or to the value of the global environment.
Other upvalues are initialized with <b>nil</b>.
All upvalues are fresh, that is,
they are not shared with any other function.
<p>
<code>chunkname</code> is used as the name of the chunk for error messages
and debug information (see <a href="#4.7">§4.7</a>).
When absent,
it defaults to <code>chunk</code>, if <code>chunk</code> is a string,
or to "<code>=(load)</code>" otherwise.
<p>
The string <code>mode</code> controls whether the chunk can be text or binary
(that is, a precompiled chunk).
It may be the string "<code>b</code>" (only binary chunks),
"<code>t</code>" (only text chunks),
or "<code>bt</code>" (both binary and text).
The default is "<code>bt</code>".
<p>
It is safe to load malformed binary chunks;
<code>load</code> signals an appropriate error.
However,
Lua does not check the consistency of the code inside binary chunks;
running maliciously crafted bytecode can crash the interpreter.
<p>
<hr><h3><a name="pdf-loadfile"><code>loadfile ([filename [, mode [, env]]])</code></a></h3>
<p>
Similar to <a href="#pdf-load"><code>load</code></a>,
but gets the chunk from file <code>filename</code>
or from the standard input,
if no file name is given.
<p>
<hr><h3><a name="pdf-next"><code>next (table [, index])</code></a></h3>
<p>
Allows a program to traverse all fields of a table.
Its first argument is a table and its second argument
is an index in this table.
A call to <code>next</code> returns the next index of the table
and its associated value.
When called with <b>nil</b> as its second argument,
<code>next</code> returns an initial index
and its associated value.
When called with the last index,
or with <b>nil</b> in an empty table,
<code>next</code> returns <b>nil</b>.
If the second argument is absent, then it is interpreted as <b>nil</b>.
In particular,
you can use <code>next(t)</code> to check whether a table is empty.
<p>
The order in which the indices are enumerated is not specified,
<em>even for numeric indices</em>.
(To traverse a table in numerical order,
use a numerical <b>for</b>.)
<p>
The behavior of <code>next</code> is undefined if,
during the traversal,
you assign any value to a non-existent field in the table.
You may however modify existing fields.
In particular, you may set existing fields to nil.
<p>
<hr><h3><a name="pdf-pairs"><code>pairs (t)</code></a></h3>
<p>
If <code>t</code> has a metamethod <code>__pairs</code>,
calls it with <code>t</code> as argument and returns the first three
results from the call.
<p>
Otherwise,
returns three values: the <a href="#pdf-next"><code>next</code></a> function, the table <code>t</code>, and <b>nil</b>,
so that the construction
<pre>
for k,v in pairs(t) do <em>body</em> end
</pre><p>
will iterate over all key–value pairs of table <code>t</code>.
<p>
See function <a href="#pdf-next"><code>next</code></a> for the caveats of modifying
the table during its traversal.
<p>
<hr><h3><a name="pdf-pcall"><code>pcall (f [, arg1, ···])</code></a></h3>
<p>
Calls the function <code>f</code> with
the given arguments in <em>protected mode</em>.
This means that any error inside <code>f</code> is not propagated;
instead, <code>pcall</code> catches the error
and returns a status code.
Its first result is the status code (a boolean),
which is true if the call succeeds without errors.
In such case, <code>pcall</code> also returns all results from the call,
after this first result.
In case of any error, <code>pcall</code> returns <b>false</b> plus the error object.
Note that errors caught by <code>pcall</code> do not call a message handler.
<p>
<hr><h3><a name="pdf-print"><code>print (···)</code></a></h3>
Receives any number of arguments
and prints their values to <code>stdout</code>,
converting each argument to a string
following the same rules of <a href="#pdf-tostring"><code>tostring</code></a>.
<p>
The function <code>print</code> is not intended for formatted output,
but only as a quick way to show a value,
for instance for debugging.
For complete control over the output,
use <a href="#pdf-string.format"><code>string.format</code></a> and <a href="#pdf-io.write"><code>io.write</code></a>.
<p>
<hr><h3><a name="pdf-rawequal"><code>rawequal (v1, v2)</code></a></h3>
Checks whether <code>v1</code> is equal to <code>v2</code>,
without invoking the <code>__eq</code> metamethod.
Returns a boolean.
<p>
<hr><h3><a name="pdf-rawget"><code>rawget (table, index)</code></a></h3>
Gets the real value of <code>table[index]</code>,
without using the <code>__index</code> metavalue.
<code>table</code> must be a table;
<code>index</code> may be any value.
<p>
<hr><h3><a name="pdf-rawlen"><code>rawlen (v)</code></a></h3>
Returns the length of the object <code>v</code>,
which must be a table or a string,
without invoking the <code>__len</code> metamethod.
Returns an integer.
<p>
<hr><h3><a name="pdf-rawset"><code>rawset (table, index, value)</code></a></h3>
Sets the real value of <code>table[index]</code> to <code>value</code>,
without using the <code>__newindex</code> metavalue.
<code>table</code> must be a table,
<code>index</code> any value different from <b>nil</b> and NaN,
and <code>value</code> any Lua value.
<p>
This function returns <code>table</code>.
<p>
<hr><h3><a name="pdf-select"><code>select (index, ···)</code></a></h3>
<p>
If <code>index</code> is a number,
returns all arguments after argument number <code>index</code>;
a negative number indexes from the end (-1 is the last argument).
Otherwise, <code>index</code> must be the string <code>"#"</code>,
and <code>select</code> returns the total number of extra arguments it received.
<p>
<hr><h3><a name="pdf-setmetatable"><code>setmetatable (table, metatable)</code></a></h3>
<p>
Sets the metatable for the given table.
If <code>metatable</code> is <b>nil</b>,
removes the metatable of the given table.
If the original metatable has a <code>__metatable</code> field,
raises an error.
<p>
This function returns <code>table</code>.
<p>
To change the metatable of other types from Lua code,
you must use the debug library (<a href="#6.10">§6.10</a>).
<p>
<hr><h3><a name="pdf-tonumber"><code>tonumber (e [, base])</code></a></h3>
<p>
When called with no <code>base</code>,
<code>tonumber</code> tries to convert its argument to a number.
If the argument is already a number or
a string convertible to a number,
then <code>tonumber</code> returns this number;
otherwise, it returns <b>fail</b>.
<p>
The conversion of strings can result in integers or floats,
according to the lexical conventions of Lua (see <a href="#3.1">§3.1</a>).
The string may have leading and trailing spaces and a sign.
<p>
When called with <code>base</code>,
then <code>e</code> must be a string to be interpreted as
an integer numeral in that base.
The base may be any integer between 2 and 36, inclusive.
In bases above 10, the letter '<code>A</code>' (in either upper or lower case)
represents 10, '<code>B</code>' represents 11, and so forth,
with '<code>Z</code>' representing 35.
If the string <code>e</code> is not a valid numeral in the given base,
the function returns <b>fail</b>.
<p>
<hr><h3><a name="pdf-tostring"><code>tostring (v)</code></a></h3>
<p>
Receives a value of any type and
converts it to a string in a human-readable format.
<p>
If the metatable of <code>v</code> has a <code>__tostring</code> field,
then <code>tostring</code> calls the corresponding value
with <code>v</code> as argument,
and uses the result of the call as its result.
Otherwise, if the metatable of <code>v</code> has a <code>__name</code> field
with a string value,
<code>tostring</code> may use that string in its final result.
<p>
For complete control of how numbers are converted,
use <a href="#pdf-string.format"><code>string.format</code></a>.
<p>
<hr><h3><a name="pdf-type"><code>type (v)</code></a></h3>
<p>
Returns the type of its only argument, coded as a string.
The possible results of this function are
"<code>nil</code>" (a string, not the value <b>nil</b>),
"<code>number</code>",
"<code>string</code>",
"<code>boolean</code>",
"<code>table</code>",
"<code>function</code>",
"<code>thread</code>",
and "<code>userdata</code>".
<p>
<hr><h3><a name="pdf-_VERSION"><code>_VERSION</code></a></h3>
<p>
A global variable (not a function) that
holds a string containing the running Lua version.
The current value of this variable is "<code>Lua 5.4</code>".
<p>
<hr><h3><a name="pdf-warn"><code>warn (msg1, ···)</code></a></h3>
<p>
Emits a warning with a message composed by the concatenation
of all its arguments (which should be strings).
<p>
By convention,
a one-piece message starting with '<code>@</code>'
is intended to be a <em>control message</em>,
which is a message to the warning system itself.
In particular, the standard warning function in Lua
recognizes the control messages "<code>@off</code>",
to stop the emission of warnings,
and "<code>@on</code>", to (re)start the emission;
it ignores unknown control messages.
<p>
<hr><h3><a name="pdf-xpcall"><code>xpcall (f, msgh [, arg1, ···])</code></a></h3>
<p>
This function is similar to <a href="#pdf-pcall"><code>pcall</code></a>,
except that it sets a new message handler <code>msgh</code>.
<h2>6.2 – <a name="6.2">Coroutine Manipulation</a></h2>
<p>
This library comprises the operations to manipulate coroutines,
which come inside the table <a name="pdf-coroutine"><code>coroutine</code></a>.
See <a href="#2.6">§2.6</a> for a general description of coroutines.
<p>
<hr><h3><a name="pdf-coroutine.close"><code>coroutine.close (co)</code></a></h3>
<p>
Closes coroutine <code>co</code>,
that is,
closes all its pending to-be-closed variables
and puts the coroutine in a dead state.
The given coroutine must be dead or suspended.
In case of error
(either the original error that stopped the coroutine or
errors in closing methods),
returns <b>false</b> plus the error object;
otherwise returns <b>true</b>.
<p>
<hr><h3><a name="pdf-coroutine.create"><code>coroutine.create (f)</code></a></h3>
<p>
Creates a new coroutine, with body <code>f</code>.
<code>f</code> must be a function.
Returns this new coroutine,
an object with type <code>"thread"</code>.
<p>
<hr><h3><a name="pdf-coroutine.isyieldable"><code>coroutine.isyieldable ([co])</code></a></h3>
<p>
Returns true when the coroutine <code>co</code> can yield.
The default for <code>co</code> is the running coroutine.
<p>
A coroutine is yieldable if it is not the main thread and
it is not inside a non-yieldable C function.
<p>
<hr><h3><a name="pdf-coroutine.resume"><code>coroutine.resume (co [, val1, ···])</code></a></h3>
<p>
Starts or continues the execution of coroutine <code>co</code>.
The first time you resume a coroutine,
it starts running its body.
The values <code>val1</code>, ... are passed
as the arguments to the body function.
If the coroutine has yielded,
<code>resume</code> restarts it;
the values <code>val1</code>, ... are passed
as the results from the yield.
<p>
If the coroutine runs without any errors,
<code>resume</code> returns <b>true</b> plus any values passed to <code>yield</code>
(when the coroutine yields) or any values returned by the body function
(when the coroutine terminates).
If there is any error,
<code>resume</code> returns <b>false</b> plus the error message.
<p>
<hr><h3><a name="pdf-coroutine.running"><code>coroutine.running ()</code></a></h3>
<p>
Returns the running coroutine plus a boolean,
true when the running coroutine is the main one.
<p>
<hr><h3><a name="pdf-coroutine.status"><code>coroutine.status (co)</code></a></h3>
<p>
Returns the status of the coroutine <code>co</code>, as a string:
<code>"running"</code>,
if the coroutine is running
(that is, it is the one that called <code>status</code>);
<code>"suspended"</code>, if the coroutine is suspended in a call to <code>yield</code>,
or if it has not started running yet;
<code>"normal"</code> if the coroutine is active but not running
(that is, it has resumed another coroutine);
and <code>"dead"</code> if the coroutine has finished its body function,
or if it has stopped with an error.
<p>
<hr><h3><a name="pdf-coroutine.wrap"><code>coroutine.wrap (f)</code></a></h3>
<p>
Creates a new coroutine, with body <code>f</code>;
<code>f</code> must be a function.
Returns a function that resumes the coroutine each time it is called.
Any arguments passed to this function behave as the
extra arguments to <code>resume</code>.
The function returns the same values returned by <code>resume</code>,
except the first boolean.
In case of error,
the function closes the coroutine and propagates the error.
<p>
<hr><h3><a name="pdf-coroutine.yield"><code>coroutine.yield (···)</code></a></h3>
<p>
Suspends the execution of the calling coroutine.
Any arguments to <code>yield</code> are passed as extra results to <code>resume</code>.
<h2>6.3 – <a name="6.3">Modules</a></h2>
<p>
The package library provides basic
facilities for loading modules in Lua.
It exports one function directly in the global environment:
<a href="#pdf-require"><code>require</code></a>.
Everything else is exported in the table <a name="pdf-package"><code>package</code></a>.
<p>
<hr><h3><a name="pdf-require"><code>require (modname)</code></a></h3>
<p>
Loads the given module.
The function starts by looking into the <a href="#pdf-package.loaded"><code>package.loaded</code></a> table
to determine whether <code>modname</code> is already loaded.
If it is, then <code>require</code> returns the value stored
at <code>package.loaded[modname]</code>.
(The absence of a second result in this case
signals that this call did not have to load the module.)
Otherwise, it tries to find a <em>loader</em> for the module.
<p>
To find a loader,
<code>require</code> is guided by the table <a href="#pdf-package.searchers"><code>package.searchers</code></a>.
Each item in this table is a search function,
that searches for the module in a particular way.
By changing this table,
we can change how <code>require</code> looks for a module.
The following explanation is based on the default configuration
for <a href="#pdf-package.searchers"><code>package.searchers</code></a>.
<p>
First <code>require</code> queries <code>package.preload[modname]</code>.
If it has a value,
this value (which must be a function) is the loader.
Otherwise <code>require</code> searches for a Lua loader using the
path stored in <a href="#pdf-package.path"><code>package.path</code></a>.
If that also fails, it searches for a C loader using the
path stored in <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
If that also fails,
it tries an <em>all-in-one</em> loader (see <a href="#pdf-package.searchers"><code>package.searchers</code></a>).
<p>
Once a loader is found,
<code>require</code> calls the loader with two arguments:
<code>modname</code> and an extra value,
a <em>loader data</em>,
also returned by the searcher.
The loader data can be any value useful to the module;
for the default searchers,
it indicates where the loader was found.
(For instance, if the loader came from a file,
this extra value is the file path.)
If the loader returns any non-nil value,
<code>require</code> assigns the returned value to <code>package.loaded[modname]</code>.
If the loader does not return a non-nil value and
has not assigned any value to <code>package.loaded[modname]</code>,
then <code>require</code> assigns <b>true</b> to this entry.
In any case, <code>require</code> returns the
final value of <code>package.loaded[modname]</code>.
Besides that value, <code>require</code> also returns as a second result
the loader data returned by the searcher,
which indicates how <code>require</code> found the module.
<p>
If there is any error loading or running the module,
or if it cannot find any loader for the module,
then <code>require</code> raises an error.
<p>
<hr><h3><a name="pdf-package.config"><code>package.config</code></a></h3>
<p>
A string describing some compile-time configurations for packages.
This string is a sequence of lines:
<ul>
<li>The first line is the directory separator string.
Default is '<code>\</code>' for Windows and '<code>/</code>' for all other systems.</li>
<li>The second line is the character that separates templates in a path.
Default is '<code>;</code>'.</li>
<li>The third line is the string that marks the
substitution points in a template.
Default is '<code>?</code>'.</li>
<li>The fourth line is a string that, in a path in Windows,
is replaced by the executable's directory.
Default is '<code>!</code>'.</li>
<li>The fifth line is a mark to ignore all text after it
when building the <code>luaopen_</code> function name.
Default is '<code>-</code>'.</li>
</ul>
<p>
<hr><h3><a name="pdf-package.cpath"><code>package.cpath</code></a></h3>
<p>
A string with the path used by <a href="#pdf-require"><code>require</code></a>
to search for a C loader.
<p>
Lua initializes the C path <a href="#pdf-package.cpath"><code>package.cpath</code></a> in the same way
it initializes the Lua path <a href="#pdf-package.path"><code>package.path</code></a>,
using the environment variable <a name="pdf-LUA_CPATH_5_4"><code>LUA_CPATH_5_4</code></a>,
or the environment variable <a name="pdf-LUA_CPATH"><code>LUA_CPATH</code></a>,
or a default path defined in <code>luaconf.h</code>.
<p>
<hr><h3><a name="pdf-package.loaded"><code>package.loaded</code></a></h3>
<p>
A table used by <a href="#pdf-require"><code>require</code></a> to control which
modules are already loaded.
When you require a module <code>modname</code> and
<code>package.loaded[modname]</code> is not false,
<a href="#pdf-require"><code>require</code></a> simply returns the value stored there.
<p>
This variable is only a reference to the real table;
assignments to this variable do not change the
table used by <a href="#pdf-require"><code>require</code></a>.
<p>
<hr><h3><a name="pdf-package.loadlib"><code>package.loadlib (libname, funcname)</code></a></h3>
<p>
Dynamically links the host program with the C library <code>libname</code>.
<p>
If <code>funcname</code> is "<code>*</code>",
then it only links with the library,
making the symbols exported by the library
available to other dynamically linked libraries.
Otherwise,
it looks for a function <code>funcname</code> inside the library
and returns this function as a C function.
So, <code>funcname</code> must follow the <a href="#lua_CFunction"><code>lua_CFunction</code></a> prototype
(see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
<p>
This is a low-level function.
It completely bypasses the package and module system.
Unlike <a href="#pdf-require"><code>require</code></a>,
it does not perform any path searching and
does not automatically adds extensions.
<code>libname</code> must be the complete file name of the C library,
including if necessary a path and an extension.
<code>funcname</code> must be the exact name exported by the C library
(which may depend on the C compiler and linker used).
<p>
This function is not supported by Standard C.
As such, it is only available on some platforms
(Windows, Linux, Mac OS X, Solaris, BSD,
plus other Unix systems that support the <code>dlfcn</code> standard).
<p>
This function is inherently insecure,
as it allows Lua to call any function in any readable dynamic
library in the system.
(Lua calls any function assuming the function
has a proper prototype and respects a proper protocol
(see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
Therefore,
calling an arbitrary function in an arbitrary dynamic library
more often than not results in an access violation.)
<p>
<hr><h3><a name="pdf-package.path"><code>package.path</code></a></h3>
<p>
A string with the path used by <a href="#pdf-require"><code>require</code></a>
to search for a Lua loader.
<p>
At start-up, Lua initializes this variable with
the value of the environment variable <a name="pdf-LUA_PATH_5_4"><code>LUA_PATH_5_4</code></a> or
the environment variable <a name="pdf-LUA_PATH"><code>LUA_PATH</code></a> or
with a default path defined in <code>luaconf.h</code>,
if those environment variables are not defined.
A "<code>;;</code>" in the value of the environment variable
is replaced by the default path.
<p>
<hr><h3><a name="pdf-package.preload"><code>package.preload</code></a></h3>
<p>
A table to store loaders for specific modules
(see <a href="#pdf-require"><code>require</code></a>).
<p>
This variable is only a reference to the real table;
assignments to this variable do not change the
table used by <a href="#pdf-require"><code>require</code></a>.
<p>
<hr><h3><a name="pdf-package.searchers"><code>package.searchers</code></a></h3>
<p>
A table used by <a href="#pdf-require"><code>require</code></a> to control how to find modules.
<p>
Each entry in this table is a <em>searcher function</em>.
When looking for a module,
<a href="#pdf-require"><code>require</code></a> calls each of these searchers in ascending order,
with the module name (the argument given to <a href="#pdf-require"><code>require</code></a>) as its
sole argument.
If the searcher finds the module,
it returns another function, the module <em>loader</em>,
plus an extra value, a <em>loader data</em>,
that will be passed to that loader and
returned as a second result by <a href="#pdf-require"><code>require</code></a>.
If it cannot find the module,
it returns a string explaining why
(or <b>nil</b> if it has nothing to say).
<p>
Lua initializes this table with four searcher functions.
<p>
The first searcher simply looks for a loader in the
<a href="#pdf-package.preload"><code>package.preload</code></a> table.
<p>
The second searcher looks for a loader as a Lua library,
using the path stored at <a href="#pdf-package.path"><code>package.path</code></a>.
The search is done as described in function <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.
<p>
The third searcher looks for a loader as a C library,
using the path given by the variable <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
Again,
the search is done as described in function <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.
For instance,
if the C path is the string
<pre>
"./?.so;./?.dll;/usr/local/?/init.so"
</pre><p>
the searcher for module <code>foo</code>
will try to open the files <code>./foo.so</code>, <code>./foo.dll</code>,
and <code>/usr/local/foo/init.so</code>, in that order.
Once it finds a C library,
this searcher first uses a dynamic link facility to link the
application with the library.
Then it tries to find a C function inside the library to
be used as the loader.
The name of this C function is the string "<code>luaopen_</code>"
concatenated with a copy of the module name where each dot
is replaced by an underscore.
Moreover, if the module name has a hyphen,
its suffix after (and including) the first hyphen is removed.
For instance, if the module name is <code>a.b.c-v2.1</code>,
the function name will be <code>luaopen_a_b_c</code>.
<p>
The fourth searcher tries an <em>all-in-one loader</em>.
It searches the C path for a library for
the root name of the given module.
For instance, when requiring <code>a.b.c</code>,
it will search for a C library for <code>a</code>.
If found, it looks into it for an open function for
the submodule;
in our example, that would be <code>luaopen_a_b_c</code>.
With this facility, a package can pack several C submodules
into one single library,
with each submodule keeping its original open function.
<p>
All searchers except the first one (preload) return as the extra value
the file path where the module was found,
as returned by <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.
The first searcher always returns the string "<code>:preload:</code>".
<p>
Searchers should raise no errors and have no side effects in Lua.
(They may have side effects in C,
for instance by linking the application with a library.)
<p>
<hr><h3><a name="pdf-package.searchpath"><code>package.searchpath (name, path [, sep [, rep]])</code></a></h3>
<p>
Searches for the given <code>name</code> in the given <code>path</code>.
<p>
A path is a string containing a sequence of
<em>templates</em> separated by semicolons.
For each template,
the function replaces each interrogation mark (if any)
in the template with a copy of <code>name</code>
wherein all occurrences of <code>sep</code>
(a dot, by default)
were replaced by <code>rep</code>
(the system's directory separator, by default),
and then tries to open the resulting file name.
<p>
For instance, if the path is the string
<pre>
"./?.lua;./?.lc;/usr/local/?/init.lua"
</pre><p>
the search for the name <code>foo.a</code>
will try to open the files
<code>./foo/a.lua</code>, <code>./foo/a.lc</code>, and
<code>/usr/local/foo/a/init.lua</code>, in that order.
<p>
Returns the resulting name of the first file that it can
open in read mode (after closing the file),
or <b>fail</b> plus an error message if none succeeds.
(This error message lists all file names it tried to open.)
<h2>6.4 – <a name="6.4">String Manipulation</a></h2>
<p>
This library provides generic functions for string manipulation,
such as finding and extracting substrings, and pattern matching.
When indexing a string in Lua, the first character is at position 1
(not at 0, as in C).
Indices are allowed to be negative and are interpreted as indexing backwards,
from the end of the string.
Thus, the last character is at position -1, and so on.
<p>
The string library provides all its functions inside the table
<a name="pdf-string"><code>string</code></a>.
It also sets a metatable for strings
where the <code>__index</code> field points to the <code>string</code> table.
Therefore, you can use the string functions in object-oriented style.
For instance, <code>string.byte(s,i)</code>
can be written as <code>s:byte(i)</code>.
<p>
The string library assumes one-byte character encodings.
<p>
<hr><h3><a name="pdf-string.byte"><code>string.byte (s [, i [, j]])</code></a></h3>
Returns the internal numeric codes of the characters <code>s[i]</code>,
<code>s[i+1]</code>, ..., <code>s[j]</code>.
The default value for <code>i</code> is 1;
the default value for <code>j</code> is <code>i</code>.
These indices are corrected
following the same rules of function <a href="#pdf-string.sub"><code>string.sub</code></a>.
<p>
Numeric codes are not necessarily portable across platforms.
<p>
<hr><h3><a name="pdf-string.char"><code>string.char (···)</code></a></h3>
Receives zero or more integers.
Returns a string with length equal to the number of arguments,
in which each character has the internal numeric code equal
to its corresponding argument.
<p>
Numeric codes are not necessarily portable across platforms.
<p>
<hr><h3><a name="pdf-string.dump"><code>string.dump (function [, strip])</code></a></h3>
<p>
Returns a string containing a binary representation
(a <em>binary chunk</em>)
of the given function,
so that a later <a href="#pdf-load"><code>load</code></a> on this string returns
a copy of the function (but with new upvalues).
If <code>strip</code> is a true value,
the binary representation may not include all debug information
about the function,
to save space.
<p>
Functions with upvalues have only their number of upvalues saved.
When (re)loaded,
those upvalues receive fresh instances.
(See the <a href="#pdf-load"><code>load</code></a> function for details about
how these upvalues are initialized.
You can use the debug library to serialize
and reload the upvalues of a function
in a way adequate to your needs.)
<p>
<hr><h3><a name="pdf-string.find"><code>string.find (s, pattern [, init [, plain]])</code></a></h3>
<p>
Looks for the first match of
<code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>) in the string <code>s</code>.
If it finds a match, then <code>find</code> returns the indices of <code>s</code>
where this occurrence starts and ends;
otherwise, it returns <b>fail</b>.
A third, optional numeric argument <code>init</code> specifies
where to start the search;
its default value is 1 and can be negative.
A value of <b>true</b> as a fourth, optional argument <code>plain</code>
turns off the pattern matching facilities,
so the function does a plain "find substring" operation,
with no characters in <code>pattern</code> being considered magic.
<p>
If the pattern has captures,
then in a successful match
the captured values are also returned,
after the two indices.
<p>
<hr><h3><a name="pdf-string.format"><code>string.format (formatstring, ···)</code></a></h3>
<p>
Returns a formatted version of its variable number of arguments
following the description given in its first argument,
which must be a string.
The format string follows the same rules as the ISO C function <code>sprintf</code>.
The only differences are that the conversion specifiers and modifiers
<code>*</code>, <code>h</code>, <code>L</code>, <code>l</code>, and <code>n</code> are not supported
and that there is an extra specifier, <code>q</code>.
<p>
The specifier <code>q</code> formats booleans, nil, numbers, and strings
in a way that the result is a valid constant in Lua source code.
Booleans and nil are written in the obvious way
(<code>true</code>, <code>false</code>, <code>nil</code>).
Floats are written in hexadecimal,
to preserve full precision.
A string is written between double quotes,
using escape sequences when necessary to ensure that
it can safely be read back by the Lua interpreter.
For instance, the call
<pre>
string.format('%q', 'a string with "quotes" and \n new line')
</pre><p>
may produce the string:
<pre>
"a string with \"quotes\" and \
new line"
</pre><p>
This specifier does not support modifiers (flags, width, length).
<p>
The conversion specifiers
<code>A</code>, <code>a</code>, <code>E</code>, <code>e</code>, <code>f</code>,
<code>G</code>, and <code>g</code> all expect a number as argument.
The specifiers <code>c</code>, <code>d</code>,
<code>i</code>, <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code>
expect an integer.
When Lua is compiled with a C89 compiler,
the specifiers <code>A</code> and <code>a</code> (hexadecimal floats)
do not support modifiers.
<p>
The specifier <code>s</code> expects a string;
if its argument is not a string,
it is converted to one following the same rules of <a href="#pdf-tostring"><code>tostring</code></a>.
If the specifier has any modifier,
the corresponding string argument should not contain embedded zeros.
<p>
The specifier <code>p</code> formats the pointer
returned by <a href="#lua_topointer"><code>lua_topointer</code></a>.
That gives a unique string identifier for tables, userdata,
threads, strings, and functions.
For other values (numbers, nil, booleans),
this specifier results in a string representing
the pointer <code>NULL</code>.
<p>
<hr><h3><a name="pdf-string.gmatch"><code>string.gmatch (s, pattern [, init])</code></a></h3>
Returns an iterator function that,
each time it is called,
returns the next captures from <code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>)
over the string <code>s</code>.
If <code>pattern</code> specifies no captures,
then the whole match is produced in each call.
A third, optional numeric argument <code>init</code> specifies
where to start the search;
its default value is 1 and can be negative.
<p>
As an example, the following loop
will iterate over all the words from string <code>s</code>,
printing one per line:
<pre>
s = "hello world from Lua"
for w in string.gmatch(s, "%a+") do
print(w)
end
</pre><p>
The next example collects all pairs <code>key=value</code> from the
given string into a table:
<pre>
t = {}
s = "from=world, to=Lua"
for k, v in string.gmatch(s, "(%w+)=(%w+)") do
t[k] = v
end
</pre>
<p>
For this function, a caret '<code>^</code>' at the start of a pattern does not
work as an anchor, as this would prevent the iteration.
<p>
<hr><h3><a name="pdf-string.gsub"><code>string.gsub (s, pattern, repl [, n])</code></a></h3>
Returns a copy of <code>s</code>
in which all (or the first <code>n</code>, if given)
occurrences of the <code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>) have been
replaced by a replacement string specified by <code>repl</code>,
which can be a string, a table, or a function.
<code>gsub</code> also returns, as its second value,
the total number of matches that occurred.
The name <code>gsub</code> comes from <em>Global SUBstitution</em>.
<p>
If <code>repl</code> is a string, then its value is used for replacement.
The character <code>%</code> works as an escape character:
any sequence in <code>repl</code> of the form <code>%<em>d</em></code>,
with <em>d</em> between 1 and 9,
stands for the value of the <em>d</em>-th captured substring;
the sequence <code>%0</code> stands for the whole match;
the sequence <code>%%</code> stands for a single <code>%</code>.
<p>
If <code>repl</code> is a table, then the table is queried for every match,
using the first capture as the key.
<p>
If <code>repl</code> is a function, then this function is called every time a
match occurs, with all captured substrings passed as arguments,
in order.
<p>
In any case,
if the pattern specifies no captures,
then it behaves as if the whole pattern was inside a capture.
<p>
If the value returned by the table query or by the function call
is a string or a number,
then it is used as the replacement string;
otherwise, if it is <b>false</b> or <b>nil</b>,
then there is no replacement
(that is, the original match is kept in the string).
<p>
Here are some examples:
<pre>
x = string.gsub("hello world", "(%w+)", "%1 %1")
--> x="hello hello world world"
x = string.gsub("hello world", "%w+", "%0 %0", 1)
--> x="hello hello world"
x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
--> x="world hello Lua from"
x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
--> x="home = /home/roberto, user = roberto"
x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
return load(s)()
end)
--> x="4+5 = 9"
local t = {name="lua", version="5.4"}
x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
--> x="lua-5.4.tar.gz"
</pre>
<p>
<hr><h3><a name="pdf-string.len"><code>string.len (s)</code></a></h3>
<p>
Receives a string and returns its length.
The empty string <code>""</code> has length 0.
Embedded zeros are counted,
so <code>"a\000bc\000"</code> has length 5.
<p>
<hr><h3><a name="pdf-string.lower"><code>string.lower (s)</code></a></h3>
<p>
Receives a string and returns a copy of this string with all
uppercase letters changed to lowercase.
All other characters are left unchanged.
The definition of what an uppercase letter is depends on the current locale.
<p>
<hr><h3><a name="pdf-string.match"><code>string.match (s, pattern [, init])</code></a></h3>
<p>
Looks for the first <em>match</em> of
the <code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>) in the string <code>s</code>.
If it finds one, then <code>match</code> returns
the captures from the pattern;
otherwise it returns <b>fail</b>.
If <code>pattern</code> specifies no captures,
then the whole match is returned.
A third, optional numeric argument <code>init</code> specifies
where to start the search;
its default value is 1 and can be negative.
<p>
<hr><h3><a name="pdf-string.pack"><code>string.pack (fmt, v1, v2, ···)</code></a></h3>
<p>
Returns a binary string containing the values <code>v1</code>, <code>v2</code>, etc.
serialized in binary form (packed)
according to the format string <code>fmt</code> (see <a href="#6.4.2">§6.4.2</a>).
<p>
<hr><h3><a name="pdf-string.packsize"><code>string.packsize (fmt)</code></a></h3>
<p>
Returns the size of a string resulting from <a href="#pdf-string.pack"><code>string.pack</code></a>
with the given format.
The format string cannot have the variable-length options
'<code>s</code>' or '<code>z</code>' (see <a href="#6.4.2">§6.4.2</a>).
<p>
<hr><h3><a name="pdf-string.rep"><code>string.rep (s, n [, sep])</code></a></h3>
<p>
Returns a string that is the concatenation of <code>n</code> copies of
the string <code>s</code> separated by the string <code>sep</code>.
The default value for <code>sep</code> is the empty string
(that is, no separator).
Returns the empty string if <code>n</code> is not positive.
<p>
(Note that it is very easy to exhaust the memory of your machine
with a single call to this function.)
<p>
<hr><h3><a name="pdf-string.reverse"><code>string.reverse (s)</code></a></h3>
<p>
Returns a string that is the string <code>s</code> reversed.
<p>
<hr><h3><a name="pdf-string.sub"><code>string.sub (s, i [, j])</code></a></h3>
<p>
Returns the substring of <code>s</code> that
starts at <code>i</code> and continues until <code>j</code>;
<code>i</code> and <code>j</code> can be negative.
If <code>j</code> is absent, then it is assumed to be equal to -1
(which is the same as the string length).
In particular,
the call <code>string.sub(s,1,j)</code> returns a prefix of <code>s</code>
with length <code>j</code>,
and <code>string.sub(s, -i)</code> (for a positive <code>i</code>)
returns a suffix of <code>s</code>
with length <code>i</code>.
<p>
If, after the translation of negative indices,
<code>i</code> is less than 1,
it is corrected to 1.
If <code>j</code> is greater than the string length,
it is corrected to that length.
If, after these corrections,
<code>i</code> is greater than <code>j</code>,
the function returns the empty string.
<p>
<hr><h3><a name="pdf-string.unpack"><code>string.unpack (fmt, s [, pos])</code></a></h3>
<p>
Returns the values packed in string <code>s</code> (see <a href="#pdf-string.pack"><code>string.pack</code></a>)
according to the format string <code>fmt</code> (see <a href="#6.4.2">§6.4.2</a>).
An optional <code>pos</code> marks where
to start reading in <code>s</code> (default is 1).
After the read values,
this function also returns the index of the first unread byte in <code>s</code>.
<p>
<hr><h3><a name="pdf-string.upper"><code>string.upper (s)</code></a></h3>
<p>
Receives a string and returns a copy of this string with all
lowercase letters changed to uppercase.
All other characters are left unchanged.
The definition of what a lowercase letter is depends on the current locale.
<h3>6.4.1 – <a name="6.4.1">Patterns</a></h3>
<p>
Patterns in Lua are described by regular strings,
which are interpreted as patterns by the pattern-matching functions
<a href="#pdf-string.find"><code>string.find</code></a>,
<a href="#pdf-string.gmatch"><code>string.gmatch</code></a>,
<a href="#pdf-string.gsub"><code>string.gsub</code></a>,
and <a href="#pdf-string.match"><code>string.match</code></a>.
This section describes the syntax and the meaning
(that is, what they match) of these strings.
<h4>Character Class:</h4><p>
A <em>character class</em> is used to represent a set of characters.
The following combinations are allowed in describing a character class:
<ul>
<li><b><em>x</em>: </b>
(where <em>x</em> is not one of the <em>magic characters</em>
<code>^$()%.[]*+-?</code>)
represents the character <em>x</em> itself.
</li>
<li><b><code>.</code>: </b> (a dot) represents all characters.</li>
<li><b><code>%a</code>: </b> represents all letters.</li>
<li><b><code>%c</code>: </b> represents all control characters.</li>
<li><b><code>%d</code>: </b> represents all digits.</li>
<li><b><code>%g</code>: </b> represents all printable characters except space.</li>
<li><b><code>%l</code>: </b> represents all lowercase letters.</li>
<li><b><code>%p</code>: </b> represents all punctuation characters.</li>
<li><b><code>%s</code>: </b> represents all space characters.</li>
<li><b><code>%u</code>: </b> represents all uppercase letters.</li>
<li><b><code>%w</code>: </b> represents all alphanumeric characters.</li>
<li><b><code>%x</code>: </b> represents all hexadecimal digits.</li>
<li><b><code>%<em>x</em></code>: </b> (where <em>x</em> is any non-alphanumeric character)
represents the character <em>x</em>.
This is the standard way to escape the magic characters.
Any non-alphanumeric character
(including all punctuation characters, even the non-magical)
can be preceded by a '<code>%</code>' to represent itself in a pattern.
</li>
<li><b><code>[<em>set</em>]</code>: </b>
represents the class which is the union of all
characters in <em>set</em>.
A range of characters can be specified by
separating the end characters of the range,
in ascending order, with a '<code>-</code>'.
All classes <code>%</code><em>x</em> described above can also be used as
components in <em>set</em>.
All other characters in <em>set</em> represent themselves.
For example, <code>[%w_]</code> (or <code>[_%w]</code>)
represents all alphanumeric characters plus the underscore,
<code>[0-7]</code> represents the octal digits,
and <code>[0-7%l%-]</code> represents the octal digits plus
the lowercase letters plus the '<code>-</code>' character.
<p>
You can put a closing square bracket in a set
by positioning it as the first character in the set.
You can put a hyphen in a set
by positioning it as the first or the last character in the set.
(You can also use an escape for both cases.)
<p>
The interaction between ranges and classes is not defined.
Therefore, patterns like <code>[%a-z]</code> or <code>[a-%%]</code>
have no meaning.
</li>
<li><b><code>[^<em>set</em>]</code>: </b>
represents the complement of <em>set</em>,
where <em>set</em> is interpreted as above.
</li>
</ul><p>
For all classes represented by single letters (<code>%a</code>, <code>%c</code>, etc.),
the corresponding uppercase letter represents the complement of the class.
For instance, <code>%S</code> represents all non-space characters.
<p>
The definitions of letter, space, and other character groups
depend on the current locale.
In particular, the class <code>[a-z]</code> may not be equivalent to <code>%l</code>.
<h4>Pattern Item:</h4><p>
A <em>pattern item</em> can be
<ul>
<li>
a single character class,
which matches any single character in the class;
</li>
<li>
a single character class followed by '<code>*</code>',
which matches sequences of zero or more characters in the class.
These repetition items will always match the longest possible sequence;
</li>
<li>
a single character class followed by '<code>+</code>',
which matches sequences of one or more characters in the class.
These repetition items will always match the longest possible sequence;
</li>
<li>
a single character class followed by '<code>-</code>',
which also matches sequences of zero or more characters in the class.
Unlike '<code>*</code>',
these repetition items will always match the shortest possible sequence;
</li>
<li>
a single character class followed by '<code>?</code>',
which matches zero or one occurrence of a character in the class.
It always matches one occurrence if possible;
</li>
<li>
<code>%<em>n</em></code>, for <em>n</em> between 1 and 9;
such item matches a substring equal to the <em>n</em>-th captured string
(see below);
</li>
<li>
<code>%b<em>xy</em></code>, where <em>x</em> and <em>y</em> are two distinct characters;
such item matches strings that start with <em>x</em>, end with <em>y</em>,
and where the <em>x</em> and <em>y</em> are <em>balanced</em>.
This means that, if one reads the string from left to right,
counting <em>+1</em> for an <em>x</em> and <em>-1</em> for a <em>y</em>,
the ending <em>y</em> is the first <em>y</em> where the count reaches 0.
For instance, the item <code>%b()</code> matches expressions with
balanced parentheses.
</li>
<li>
<code>%f[<em>set</em>]</code>, a <em>frontier pattern</em>;
such item matches an empty string at any position such that
the next character belongs to <em>set</em>
and the previous character does not belong to <em>set</em>.
The set <em>set</em> is interpreted as previously described.
The beginning and the end of the subject are handled as if
they were the character '<code>\0</code>'.
</li>
</ul>
<h4>Pattern:</h4><p>
A <em>pattern</em> is a sequence of pattern items.
A caret '<code>^</code>' at the beginning of a pattern anchors the match at the
beginning of the subject string.
A '<code>$</code>' at the end of a pattern anchors the match at the
end of the subject string.
At other positions,
'<code>^</code>' and '<code>$</code>' have no special meaning and represent themselves.
<h4>Captures:</h4><p>
A pattern can contain sub-patterns enclosed in parentheses;
they describe <em>captures</em>.
When a match succeeds, the substrings of the subject string
that match captures are stored (<em>captured</em>) for future use.
Captures are numbered according to their left parentheses.
For instance, in the pattern <code>"(a*(.)%w(%s*))"</code>,
the part of the string matching <code>"a*(.)%w(%s*)"</code> is
stored as the first capture, and therefore has number 1;
the character matching "<code>.</code>" is captured with number 2,
and the part matching "<code>%s*</code>" has number 3.
<p>
As a special case, the capture <code>()</code> captures
the current string position (a number).
For instance, if we apply the pattern <code>"()aa()"</code> on the
string <code>"flaaap"</code>, there will be two captures: 3 and 5.
<h4>Multiple matches:</h4><p>
The function <a href="#pdf-string.gsub"><code>string.gsub</code></a> and the iterator <a href="#pdf-string.gmatch"><code>string.gmatch</code></a>
match multiple occurrences of the given pattern in the subject.
For these functions,
a new match is considered valid only
if it ends at least one byte after the end of the previous match.
In other words, the pattern machine never accepts the
empty string as a match immediately after another match.
As an example,
consider the results of the following code:
<pre>
> string.gsub("abc", "()a*()", print);
--> 1 2
--> 3 3
--> 4 4
</pre><p>
The second and third results come from Lua matching an empty
string after '<code>b</code>' and another one after '<code>c</code>'.
Lua does not match an empty string after '<code>a</code>',
because it would end at the same position of the previous match.
<h3>6.4.2 – <a name="6.4.2">Format Strings for Pack and Unpack</a></h3>
<p>
The first argument to <a href="#pdf-string.pack"><code>string.pack</code></a>,
<a href="#pdf-string.packsize"><code>string.packsize</code></a>, and <a href="#pdf-string.unpack"><code>string.unpack</code></a>
is a format string,
which describes the layout of the structure being created or read.
<p>
A format string is a sequence of conversion options.
The conversion options are as follows:
<ul>
<li><b><code><</code>: </b>sets little endian</li>
<li><b><code>></code>: </b>sets big endian</li>
<li><b><code>=</code>: </b>sets native endian</li>
<li><b><code>![<em>n</em>]</code>: </b>sets maximum alignment to <code>n</code>
(default is native alignment)</li>
<li><b><code>b</code>: </b>a signed byte (<code>char</code>)</li>
<li><b><code>B</code>: </b>an unsigned byte (<code>char</code>)</li>
<li><b><code>h</code>: </b>a signed <code>short</code> (native size)</li>
<li><b><code>H</code>: </b>an unsigned <code>short</code> (native size)</li>
<li><b><code>l</code>: </b>a signed <code>long</code> (native size)</li>
<li><b><code>L</code>: </b>an unsigned <code>long</code> (native size)</li>
<li><b><code>j</code>: </b>a <code>lua_Integer</code></li>
<li><b><code>J</code>: </b>a <code>lua_Unsigned</code></li>
<li><b><code>T</code>: </b>a <code>size_t</code> (native size)</li>
<li><b><code>i[<em>n</em>]</code>: </b>a signed <code>int</code> with <code>n</code> bytes
(default is native size)</li>
<li><b><code>I[<em>n</em>]</code>: </b>an unsigned <code>int</code> with <code>n</code> bytes
(default is native size)</li>
<li><b><code>f</code>: </b>a <code>float</code> (native size)</li>
<li><b><code>d</code>: </b>a <code>double</code> (native size)</li>
<li><b><code>n</code>: </b>a <code>lua_Number</code></li>
<li><b><code>c<em>n</em></code>: </b>a fixed-sized string with <code>n</code> bytes</li>
<li><b><code>z</code>: </b>a zero-terminated string</li>
<li><b><code>s[<em>n</em>]</code>: </b>a string preceded by its length
coded as an unsigned integer with <code>n</code> bytes
(default is a <code>size_t</code>)</li>
<li><b><code>x</code>: </b>one byte of padding</li>
<li><b><code>X<em>op</em></code>: </b>an empty item that aligns
according to option <code>op</code>
(which is otherwise ignored)</li>
<li><b>'<code> </code>': </b>(space) ignored</li>
</ul><p>
(A "<code>[<em>n</em>]</code>" means an optional integral numeral.)
Except for padding, spaces, and configurations
(options "<code>xX <=>!</code>"),
each option corresponds to an argument in <a href="#pdf-string.pack"><code>string.pack</code></a>
or a result in <a href="#pdf-string.unpack"><code>string.unpack</code></a>.
<p>
For options "<code>!<em>n</em></code>", "<code>s<em>n</em></code>", "<code>i<em>n</em></code>", and "<code>I<em>n</em></code>",
<code>n</code> can be any integer between 1 and 16.
All integral options check overflows;
<a href="#pdf-string.pack"><code>string.pack</code></a> checks whether the given value fits in the given size;
<a href="#pdf-string.unpack"><code>string.unpack</code></a> checks whether the read value fits in a Lua integer.
For the unsigned options,
Lua integers are treated as unsigned values too.
<p>
Any format string starts as if prefixed by "<code>!1=</code>",
that is,
with maximum alignment of 1 (no alignment)
and native endianness.
<p>
Native endianness assumes that the whole system is
either big or little endian.
The packing functions will not emulate correctly the behavior
of mixed-endian formats.
<p>
Alignment works as follows:
For each option,
the format gets extra padding until the data starts
at an offset that is a multiple of the minimum between the
option size and the maximum alignment;
this minimum must be a power of 2.
Options "<code>c</code>" and "<code>z</code>" are not aligned;
option "<code>s</code>" follows the alignment of its starting integer.
<p>
All padding is filled with zeros by <a href="#pdf-string.pack"><code>string.pack</code></a>
and ignored by <a href="#pdf-string.unpack"><code>string.unpack</code></a>.
<h2>6.5 – <a name="6.5">UTF-8 Support</a></h2>
<p>
This library provides basic support for UTF-8 encoding.
It provides all its functions inside the table <a name="pdf-utf8"><code>utf8</code></a>.
This library does not provide any support for Unicode other
than the handling of the encoding.
Any operation that needs the meaning of a character,
such as character classification, is outside its scope.
<p>
Unless stated otherwise,
all functions that expect a byte position as a parameter
assume that the given position is either the start of a byte sequence
or one plus the length of the subject string.
As in the string library,
negative indices count from the end of the string.
<p>
Functions that create byte sequences
accept all values up to <code>0x7FFFFFFF</code>,
as defined in the original UTF-8 specification;
that implies byte sequences of up to six bytes.
<p>
Functions that interpret byte sequences only accept
valid sequences (well formed and not overlong).
By default, they only accept byte sequences
that result in valid Unicode code points,
rejecting values greater than <code>10FFFF</code> and surrogates.
A boolean argument <code>lax</code>, when available,
lifts these checks,
so that all values up to <code>0x7FFFFFFF</code> are accepted.
(Not well formed and overlong sequences are still rejected.)
<p>
<hr><h3><a name="pdf-utf8.char"><code>utf8.char (···)</code></a></h3>
<p>
Receives zero or more integers,
converts each one to its corresponding UTF-8 byte sequence
and returns a string with the concatenation of all these sequences.
<p>
<hr><h3><a name="pdf-utf8.charpattern"><code>utf8.charpattern</code></a></h3>
<p>
The pattern (a string, not a function) "<code>[\0-\x7F\xC2-\xFD][\x80-\xBF]*</code>"
(see <a href="#6.4.1">§6.4.1</a>),
which matches exactly one UTF-8 byte sequence,
assuming that the subject is a valid UTF-8 string.
<p>
<hr><h3><a name="pdf-utf8.codes"><code>utf8.codes (s [, lax])</code></a></h3>
<p>
Returns values so that the construction
<pre>
for p, c in utf8.codes(s) do <em>body</em> end
</pre><p>
will iterate over all UTF-8 characters in string <code>s</code>,
with <code>p</code> being the position (in bytes) and <code>c</code> the code point
of each character.
It raises an error if it meets any invalid byte sequence.
<p>
<hr><h3><a name="pdf-utf8.codepoint"><code>utf8.codepoint (s [, i [, j [, lax]]])</code></a></h3>
<p>
Returns the code points (as integers) from all characters in <code>s</code>
that start between byte position <code>i</code> and <code>j</code> (both included).
The default for <code>i</code> is 1 and for <code>j</code> is <code>i</code>.
It raises an error if it meets any invalid byte sequence.
<p>
<hr><h3><a name="pdf-utf8.len"><code>utf8.len (s [, i [, j [, lax]]])</code></a></h3>
<p>
Returns the number of UTF-8 characters in string <code>s</code>
that start between positions <code>i</code> and <code>j</code> (both inclusive).
The default for <code>i</code> is 1 and for <code>j</code> is -1.
If it finds any invalid byte sequence,
returns <b>fail</b> plus the position of the first invalid byte.
<p>
<hr><h3><a name="pdf-utf8.offset"><code>utf8.offset (s, n [, i])</code></a></h3>
<p>
Returns the position (in bytes) where the encoding of the
<code>n</code>-th character of <code>s</code>
(counting from position <code>i</code>) starts.
A negative <code>n</code> gets characters before position <code>i</code>.
The default for <code>i</code> is 1 when <code>n</code> is non-negative
and <code>#s + 1</code> otherwise,
so that <code>utf8.offset(s, -n)</code> gets the offset of the
<code>n</code>-th character from the end of the string.
If the specified character is neither in the subject
nor right after its end,
the function returns <b>fail</b>.
<p>
As a special case,
when <code>n</code> is 0 the function returns the start of the encoding
of the character that contains the <code>i</code>-th byte of <code>s</code>.
<p>
This function assumes that <code>s</code> is a valid UTF-8 string.
<h2>6.6 – <a name="6.6">Table Manipulation</a></h2>
<p>
This library provides generic functions for table manipulation.
It provides all its functions inside the table <a name="pdf-table"><code>table</code></a>.
<p>
Remember that, whenever an operation needs the length of a table,
all caveats about the length operator apply (see <a href="#3.4.7">§3.4.7</a>).
All functions ignore non-numeric keys
in the tables given as arguments.
<p>
<hr><h3><a name="pdf-table.concat"><code>table.concat (list [, sep [, i [, j]]])</code></a></h3>
<p>
Given a list where all elements are strings or numbers,
returns the string <code>list[i]..sep..list[i+1] ··· sep..list[j]</code>.
The default value for <code>sep</code> is the empty string,
the default for <code>i</code> is 1,
and the default for <code>j</code> is <code>#list</code>.
If <code>i</code> is greater than <code>j</code>, returns the empty string.
<p>
<hr><h3><a name="pdf-table.insert"><code>table.insert (list, [pos,] value)</code></a></h3>
<p>
Inserts element <code>value</code> at position <code>pos</code> in <code>list</code>,
shifting up the elements
<code>list[pos], list[pos+1], ···, list[#list]</code>.
The default value for <code>pos</code> is <code>#list+1</code>,
so that a call <code>table.insert(t,x)</code> inserts <code>x</code> at the end
of the list <code>t</code>.
<p>
<hr><h3><a name="pdf-table.move"><code>table.move (a1, f, e, t [,a2])</code></a></h3>
<p>
Moves elements from the table <code>a1</code> to the table <code>a2</code>,
performing the equivalent to the following
multiple assignment:
<code>a2[t],··· = a1[f],···,a1[e]</code>.
The default for <code>a2</code> is <code>a1</code>.
The destination range can overlap with the source range.
The number of elements to be moved must fit in a Lua integer.
<p>
Returns the destination table <code>a2</code>.
<p>
<hr><h3><a name="pdf-table.pack"><code>table.pack (···)</code></a></h3>
<p>
Returns a new table with all arguments stored into keys 1, 2, etc.
and with a field "<code>n</code>" with the total number of arguments.
Note that the resulting table may not be a sequence,
if some arguments are <b>nil</b>.
<p>
<hr><h3><a name="pdf-table.remove"><code>table.remove (list [, pos])</code></a></h3>
<p>
Removes from <code>list</code> the element at position <code>pos</code>,
returning the value of the removed element.
When <code>pos</code> is an integer between 1 and <code>#list</code>,
it shifts down the elements
<code>list[pos+1], list[pos+2], ···, list[#list]</code>
and erases element <code>list[#list]</code>;
The index <code>pos</code> can also be 0 when <code>#list</code> is 0,
or <code>#list + 1</code>.
<p>
The default value for <code>pos</code> is <code>#list</code>,
so that a call <code>table.remove(l)</code> removes the last element
of the list <code>l</code>.
<p>
<hr><h3><a name="pdf-table.sort"><code>table.sort (list [, comp])</code></a></h3>
<p>
Sorts the list elements in a given order, <em>in-place</em>,
from <code>list[1]</code> to <code>list[#list]</code>.
If <code>comp</code> is given,
then it must be a function that receives two list elements
and returns true when the first element must come
before the second in the final order,
so that, after the sort,
<code>i <= j</code> implies <code>not comp(list[j],list[i])</code>.
If <code>comp</code> is not given,
then the standard Lua operator <code><</code> is used instead.
<p>
The <code>comp</code> function must define a consistent order;
more formally, the function must define a strict weak order.
(A weak order is similar to a total order,
but it can equate different elements for comparison purposes.)
<p>
The sort algorithm is not stable:
Different elements considered equal by the given order
may have their relative positions changed by the sort.
<p>
<hr><h3><a name="pdf-table.unpack"><code>table.unpack (list [, i [, j]])</code></a></h3>
<p>
Returns the elements from the given list.
This function is equivalent to
<pre>
return list[i], list[i+1], ···, list[j]
</pre><p>
By default, <code>i</code> is 1 and <code>j</code> is <code>#list</code>.
<h2>6.7 – <a name="6.7">Mathematical Functions</a></h2>
<p>
This library provides basic mathematical functions.
It provides all its functions and constants inside the table <a name="pdf-math"><code>math</code></a>.
Functions with the annotation "<code>integer/float</code>" give
integer results for integer arguments
and float results for non-integer arguments.
The rounding functions
<a href="#pdf-math.ceil"><code>math.ceil</code></a>, <a href="#pdf-math.floor"><code>math.floor</code></a>, and <a href="#pdf-math.modf"><code>math.modf</code></a>
return an integer when the result fits in the range of an integer,
or a float otherwise.
<p>
<hr><h3><a name="pdf-math.abs"><code>math.abs (x)</code></a></h3>
<p>
Returns the maximum value between <code>x</code> and <code>-x</code>. (integer/float)
<p>
<hr><h3><a name="pdf-math.acos"><code>math.acos (x)</code></a></h3>
<p>
Returns the arc cosine of <code>x</code> (in radians).
<p>
<hr><h3><a name="pdf-math.asin"><code>math.asin (x)</code></a></h3>
<p>
Returns the arc sine of <code>x</code> (in radians).
<p>
<hr><h3><a name="pdf-math.atan"><code>math.atan (y [, x])</code></a></h3>
<p>
Returns the arc tangent of <code>y/x</code> (in radians),
but uses the signs of both arguments to find the
quadrant of the result.
It also handles correctly the case of <code>x</code> being zero.
<p>
The default value for <code>x</code> is 1,
so that the call <code>math.atan(y)</code>
returns the arc tangent of <code>y</code>.
<p>
<hr><h3><a name="pdf-math.ceil"><code>math.ceil (x)</code></a></h3>
<p>
Returns the smallest integral value greater than or equal to <code>x</code>.
<p>
<hr><h3><a name="pdf-math.cos"><code>math.cos (x)</code></a></h3>
<p>
Returns the cosine of <code>x</code> (assumed to be in radians).
<p>
<hr><h3><a name="pdf-math.deg"><code>math.deg (x)</code></a></h3>
<p>
Converts the angle <code>x</code> from radians to degrees.
<p>
<hr><h3><a name="pdf-math.exp"><code>math.exp (x)</code></a></h3>
<p>
Returns the value <em>e<sup>x</sup></em>
(where <code>e</code> is the base of natural logarithms).
<p>
<hr><h3><a name="pdf-math.floor"><code>math.floor (x)</code></a></h3>
<p>
Returns the largest integral value less than or equal to <code>x</code>.
<p>
<hr><h3><a name="pdf-math.fmod"><code>math.fmod (x, y)</code></a></h3>
<p>
Returns the remainder of the division of <code>x</code> by <code>y</code>
that rounds the quotient towards zero. (integer/float)
<p>
<hr><h3><a name="pdf-math.huge"><code>math.huge</code></a></h3>
<p>
The float value <code>HUGE_VAL</code>,
a value greater than any other numeric value.
<p>
<hr><h3><a name="pdf-math.log"><code>math.log (x [, base])</code></a></h3>
<p>
Returns the logarithm of <code>x</code> in the given base.
The default for <code>base</code> is <em>e</em>
(so that the function returns the natural logarithm of <code>x</code>).
<p>
<hr><h3><a name="pdf-math.max"><code>math.max (x, ···)</code></a></h3>
<p>
Returns the argument with the maximum value,
according to the Lua operator <code><</code>.
<p>
<hr><h3><a name="pdf-math.maxinteger"><code>math.maxinteger</code></a></h3>
An integer with the maximum value for an integer.
<p>
<hr><h3><a name="pdf-math.min"><code>math.min (x, ···)</code></a></h3>
<p>
Returns the argument with the minimum value,
according to the Lua operator <code><</code>.
<p>
<hr><h3><a name="pdf-math.mininteger"><code>math.mininteger</code></a></h3>
An integer with the minimum value for an integer.
<p>
<hr><h3><a name="pdf-math.modf"><code>math.modf (x)</code></a></h3>
<p>
Returns the integral part of <code>x</code> and the fractional part of <code>x</code>.
Its second result is always a float.
<p>
<hr><h3><a name="pdf-math.pi"><code>math.pi</code></a></h3>
<p>
The value of <em>π</em>.
<p>
<hr><h3><a name="pdf-math.rad"><code>math.rad (x)</code></a></h3>
<p>
Converts the angle <code>x</code> from degrees to radians.
<p>
<hr><h3><a name="pdf-math.random"><code>math.random ([m [, n]])</code></a></h3>
<p>
When called without arguments,
returns a pseudo-random float with uniform distribution
in the range <em>[0,1)</em>.
When called with two integers <code>m</code> and <code>n</code>,
<code>math.random</code> returns a pseudo-random integer
with uniform distribution in the range <em>[m, n]</em>.
The call <code>math.random(n)</code>, for a positive <code>n</code>,
is equivalent to <code>math.random(1,n)</code>.
The call <code>math.random(0)</code> produces an integer with
all bits (pseudo)random.
<p>
This function uses the <code>xoshiro256**</code> algorithm to produce
pseudo-random 64-bit integers,
which are the results of calls with argument 0.
Other results (ranges and floats)
are unbiased extracted from these integers.
<p>
Lua initializes its pseudo-random generator with the equivalent of
a call to <a href="#pdf-math.randomseed"><code>math.randomseed</code></a> with no arguments,
so that <code>math.random</code> should generate
different sequences of results each time the program runs.
<p>
<hr><h3><a name="pdf-math.randomseed"><code>math.randomseed ([x [, y]])</code></a></h3>
<p>
When called with at least one argument,
the integer parameters <code>x</code> and <code>y</code> are
joined into a 128-bit <em>seed</em> that
is used to reinitialize the pseudo-random generator;
equal seeds produce equal sequences of numbers.
The default for <code>y</code> is zero.
<p>
When called with no arguments,
Lua generates a seed with
a weak attempt for randomness.
<p>
This function returns the two seed components
that were effectively used,
so that setting them again repeats the sequence.
<p>
To ensure a required level of randomness to the initial state
(or contrarily, to have a deterministic sequence,
for instance when debugging a program),
you should call <a href="#pdf-math.randomseed"><code>math.randomseed</code></a> with explicit arguments.
<p>
<hr><h3><a name="pdf-math.sin"><code>math.sin (x)</code></a></h3>
<p>
Returns the sine of <code>x</code> (assumed to be in radians).
<p>
<hr><h3><a name="pdf-math.sqrt"><code>math.sqrt (x)</code></a></h3>
<p>
Returns the square root of <code>x</code>.
(You can also use the expression <code>x^0.5</code> to compute this value.)
<p>
<hr><h3><a name="pdf-math.tan"><code>math.tan (x)</code></a></h3>
<p>
Returns the tangent of <code>x</code> (assumed to be in radians).
<p>
<hr><h3><a name="pdf-math.tointeger"><code>math.tointeger (x)</code></a></h3>
<p>
If the value <code>x</code> is convertible to an integer,
returns that integer.
Otherwise, returns <b>fail</b>.
<p>
<hr><h3><a name="pdf-math.type"><code>math.type (x)</code></a></h3>
<p>
Returns "<code>integer</code>" if <code>x</code> is an integer,
"<code>float</code>" if it is a float,
or <b>fail</b> if <code>x</code> is not a number.
<p>
<hr><h3><a name="pdf-math.ult"><code>math.ult (m, n)</code></a></h3>
<p>
Returns a boolean,
true if and only if integer <code>m</code> is below integer <code>n</code> when
they are compared as unsigned integers.
<h2>6.8 – <a name="6.8">Input and Output Facilities</a></h2>
<p>
The I/O library provides two different styles for file manipulation.
The first one uses implicit file handles;
that is, there are operations to set a default input file and a
default output file,
and all input/output operations are done over these default files.
The second style uses explicit file handles.
<p>
When using implicit file handles,
all operations are supplied by table <a name="pdf-io"><code>io</code></a>.
When using explicit file handles,
the operation <a href="#pdf-io.open"><code>io.open</code></a> returns a file handle
and then all operations are supplied as methods of the file handle.
<p>
The metatable for file handles provides metamethods
for <code>__gc</code> and <code>__close</code> that try
to close the file when called.
<p>
The table <code>io</code> also provides
three predefined file handles with their usual meanings from C:
<a name="pdf-io.stdin"><code>io.stdin</code></a>, <a name="pdf-io.stdout"><code>io.stdout</code></a>, and <a name="pdf-io.stderr"><code>io.stderr</code></a>.
The I/O library never closes these files.
<p>
Unless otherwise stated,
all I/O functions return <b>fail</b> on failure,
plus an error message as a second result and
a system-dependent error code as a third result,
and some non-false value on success.
On non-POSIX systems,
the computation of the error message and error code
in case of errors
may be not thread safe,
because they rely on the global C variable <code>errno</code>.
<p>
<hr><h3><a name="pdf-io.close"><code>io.close ([file])</code></a></h3>
<p>
Equivalent to <code>file:close()</code>.
Without a <code>file</code>, closes the default output file.
<p>
<hr><h3><a name="pdf-io.flush"><code>io.flush ()</code></a></h3>
<p>
Equivalent to <code>io.output():flush()</code>.
<p>
<hr><h3><a name="pdf-io.input"><code>io.input ([file])</code></a></h3>
<p>
When called with a file name, it opens the named file (in text mode),
and sets its handle as the default input file.
When called with a file handle,
it simply sets this file handle as the default input file.
When called without arguments,
it returns the current default input file.
<p>
In case of errors this function raises the error,
instead of returning an error code.
<p>
<hr><h3><a name="pdf-io.lines"><code>io.lines ([filename, ···])</code></a></h3>
<p>
Opens the given file name in read mode
and returns an iterator function that
works like <code>file:lines(···)</code> over the opened file.
When the iterator function fails to read any value,
it automatically closes the file.
Besides the iterator function,
<code>io.lines</code> returns three other values:
two <b>nil</b> values as placeholders,
plus the created file handle.
Therefore, when used in a generic <b>for</b> loop,
the file is closed also if the loop is interrupted by an
error or a <b>break</b>.
<p>
The call <code>io.lines()</code> (with no file name) is equivalent
to <code>io.input():lines("l")</code>;
that is, it iterates over the lines of the default input file.
In this case, the iterator does not close the file when the loop ends.
<p>
In case of errors opening the file,
this function raises the error,
instead of returning an error code.
<p>
<hr><h3><a name="pdf-io.open"><code>io.open (filename [, mode])</code></a></h3>
<p>
This function opens a file,
in the mode specified in the string <code>mode</code>.
In case of success,
it returns a new file handle.
<p>
The <code>mode</code> string can be any of the following:
<ul>
<li><b>"<code>r</code>": </b> read mode (the default);</li>
<li><b>"<code>w</code>": </b> write mode;</li>
<li><b>"<code>a</code>": </b> append mode;</li>
<li><b>"<code>r+</code>": </b> update mode, all previous data is preserved;</li>
<li><b>"<code>w+</code>": </b> update mode, all previous data is erased;</li>
<li><b>"<code>a+</code>": </b> append update mode, previous data is preserved,
writing is only allowed at the end of file.</li>
</ul><p>
The <code>mode</code> string can also have a '<code>b</code>' at the end,
which is needed in some systems to open the file in binary mode.
<p>
<hr><h3><a name="pdf-io.output"><code>io.output ([file])</code></a></h3>
<p>
Similar to <a href="#pdf-io.input"><code>io.input</code></a>, but operates over the default output file.
<p>
<hr><h3><a name="pdf-io.popen"><code>io.popen (prog [, mode])</code></a></h3>
<p>
This function is system dependent and is not available
on all platforms.
<p>
Starts the program <code>prog</code> in a separated process and returns
a file handle that you can use to read data from this program
(if <code>mode</code> is <code>"r"</code>, the default)
or to write data to this program
(if <code>mode</code> is <code>"w"</code>).
<p>
<hr><h3><a name="pdf-io.read"><code>io.read (···)</code></a></h3>
<p>
Equivalent to <code>io.input():read(···)</code>.
<p>
<hr><h3><a name="pdf-io.tmpfile"><code>io.tmpfile ()</code></a></h3>
<p>
In case of success,
returns a handle for a temporary file.
This file is opened in update mode
and it is automatically removed when the program ends.
<p>
<hr><h3><a name="pdf-io.type"><code>io.type (obj)</code></a></h3>
<p>
Checks whether <code>obj</code> is a valid file handle.
Returns the string <code>"file"</code> if <code>obj</code> is an open file handle,
<code>"closed file"</code> if <code>obj</code> is a closed file handle,
or <b>fail</b> if <code>obj</code> is not a file handle.
<p>
<hr><h3><a name="pdf-io.write"><code>io.write (···)</code></a></h3>
<p>
Equivalent to <code>io.output():write(···)</code>.
<p>
<hr><h3><a name="pdf-file:close"><code>file:close ()</code></a></h3>
<p>
Closes <code>file</code>.
Note that files are automatically closed when
their handles are garbage collected,
but that takes an unpredictable amount of time to happen.
<p>
When closing a file handle created with <a href="#pdf-io.popen"><code>io.popen</code></a>,
<a href="#pdf-file:close"><code>file:close</code></a> returns the same values
returned by <a href="#pdf-os.execute"><code>os.execute</code></a>.
<p>
<hr><h3><a name="pdf-file:flush"><code>file:flush ()</code></a></h3>
<p>
Saves any written data to <code>file</code>.
<p>
<hr><h3><a name="pdf-file:lines"><code>file:lines (···)</code></a></h3>
<p>
Returns an iterator function that,
each time it is called,
reads the file according to the given formats.
When no format is given,
uses "<code>l</code>" as a default.
As an example, the construction
<pre>
for c in file:lines(1) do <em>body</em> end
</pre><p>
will iterate over all characters of the file,
starting at the current position.
Unlike <a href="#pdf-io.lines"><code>io.lines</code></a>, this function does not close the file
when the loop ends.
<p>
<hr><h3><a name="pdf-file:read"><code>file:read (···)</code></a></h3>
<p>
Reads the file <code>file</code>,
according to the given formats, which specify what to read.
For each format,
the function returns a string or a number with the characters read,
or <b>fail</b> if it cannot read data with the specified format.
(In this latter case,
the function does not read subsequent formats.)
When called without arguments,
it uses a default format that reads the next line
(see below).
<p>
The available formats are
<ul>
<li><b>"<code>n</code>": </b>
reads a numeral and returns it as a float or an integer,
following the lexical conventions of Lua.
(The numeral may have leading whitespaces and a sign.)
This format always reads the longest input sequence that
is a valid prefix for a numeral;
if that prefix does not form a valid numeral
(e.g., an empty string, "<code>0x</code>", or "<code>3.4e-</code>")
or it is too long (more than 200 characters),
it is discarded and the format returns <b>fail</b>.
</li>
<li><b>"<code>a</code>": </b>
reads the whole file, starting at the current position.
On end of file, it returns the empty string;
this format never fails.
</li>
<li><b>"<code>l</code>": </b>
reads the next line skipping the end of line,
returning <b>fail</b> on end of file.
This is the default format.
</li>
<li><b>"<code>L</code>": </b>
reads the next line keeping the end-of-line character (if present),
returning <b>fail</b> on end of file.
</li>
<li><b><em>number</em>: </b>
reads a string with up to this number of bytes,
returning <b>fail</b> on end of file.
If <code>number</code> is zero,
it reads nothing and returns an empty string,
or <b>fail</b> on end of file.
</li>
</ul><p>
The formats "<code>l</code>" and "<code>L</code>" should be used only for text files.
<p>
<hr><h3><a name="pdf-file:seek"><code>file:seek ([whence [, offset]])</code></a></h3>
<p>
Sets and gets the file position,
measured from the beginning of the file,
to the position given by <code>offset</code> plus a base
specified by the string <code>whence</code>, as follows:
<ul>
<li><b>"<code>set</code>": </b> base is position 0 (beginning of the file);</li>
<li><b>"<code>cur</code>": </b> base is current position;</li>
<li><b>"<code>end</code>": </b> base is end of file;</li>
</ul><p>
In case of success, <code>seek</code> returns the final file position,
measured in bytes from the beginning of the file.
If <code>seek</code> fails, it returns <b>fail</b>,
plus a string describing the error.
<p>
The default value for <code>whence</code> is <code>"cur"</code>,
and for <code>offset</code> is 0.
Therefore, the call <code>file:seek()</code> returns the current
file position, without changing it;
the call <code>file:seek("set")</code> sets the position to the
beginning of the file (and returns 0);
and the call <code>file:seek("end")</code> sets the position to the
end of the file, and returns its size.
<p>
<hr><h3><a name="pdf-file:setvbuf"><code>file:setvbuf (mode [, size])</code></a></h3>
<p>
Sets the buffering mode for a file.
There are three available modes:
<ul>
<li><b>"<code>no</code>": </b> no buffering.</li>
<li><b>"<code>full</code>": </b> full buffering.</li>
<li><b>"<code>line</code>": </b> line buffering.</li>
</ul>
<p>
For the last two cases,
<code>size</code> is a hint for the size of the buffer, in bytes.
The default is an appropriate size.
<p>
The specific behavior of each mode is non portable;
check the underlying ISO C function <code>setvbuf</code> in your platform for
more details.
<p>
<hr><h3><a name="pdf-file:write"><code>file:write (···)</code></a></h3>
<p>
Writes the value of each of its arguments to <code>file</code>.
The arguments must be strings or numbers.
<p>
In case of success, this function returns <code>file</code>.
<h2>6.9 – <a name="6.9">Operating System Facilities</a></h2>
<p>
This library is implemented through table <a name="pdf-os"><code>os</code></a>.
<p>
<hr><h3><a name="pdf-os.clock"><code>os.clock ()</code></a></h3>
<p>
Returns an approximation of the amount in seconds of CPU time
used by the program,
as returned by the underlying ISO C function <code>clock</code>.
<p>
<hr><h3><a name="pdf-os.date"><code>os.date ([format [, time]])</code></a></h3>
<p>
Returns a string or a table containing date and time,
formatted according to the given string <code>format</code>.
<p>
If the <code>time</code> argument is present,
this is the time to be formatted
(see the <a href="#pdf-os.time"><code>os.time</code></a> function for a description of this value).
Otherwise, <code>date</code> formats the current time.
<p>
If <code>format</code> starts with '<code>!</code>',
then the date is formatted in Coordinated Universal Time.
After this optional character,
if <code>format</code> is the string "<code>*t</code>",
then <code>date</code> returns a table with the following fields:
<code>year</code>, <code>month</code> (1–12), <code>day</code> (1–31),
<code>hour</code> (0–23), <code>min</code> (0–59),
<code>sec</code> (0–61, due to leap seconds),
<code>wday</code> (weekday, 1–7, Sunday is 1),
<code>yday</code> (day of the year, 1–366),
and <code>isdst</code> (daylight saving flag, a boolean).
This last field may be absent
if the information is not available.
<p>
If <code>format</code> is not "<code>*t</code>",
then <code>date</code> returns the date as a string,
formatted according to the same rules as the ISO C function <code>strftime</code>.
<p>
If <code>format</code> is absent, it defaults to "<code>%c</code>",
which gives a human-readable date and time representation
using the current locale.
<p>
On non-POSIX systems,
this function may be not thread safe
because of its reliance on C function <code>gmtime</code> and C function <code>localtime</code>.
<p>
<hr><h3><a name="pdf-os.difftime"><code>os.difftime (t2, t1)</code></a></h3>
<p>
Returns the difference, in seconds,
from time <code>t1</code> to time <code>t2</code>
(where the times are values returned by <a href="#pdf-os.time"><code>os.time</code></a>).
In POSIX, Windows, and some other systems,
this value is exactly <code>t2</code><em>-</em><code>t1</code>.
<p>
<hr><h3><a name="pdf-os.execute"><code>os.execute ([command])</code></a></h3>
<p>
This function is equivalent to the ISO C function <code>system</code>.
It passes <code>command</code> to be executed by an operating system shell.
Its first result is <b>true</b>
if the command terminated successfully,
or <b>fail</b> otherwise.
After this first result
the function returns a string plus a number,
as follows:
<ul>
<li><b>"<code>exit</code>": </b>
the command terminated normally;
the following number is the exit status of the command.
</li>
<li><b>"<code>signal</code>": </b>
the command was terminated by a signal;
the following number is the signal that terminated the command.
</li>
</ul>
<p>
When called without a <code>command</code>,
<code>os.execute</code> returns a boolean that is true if a shell is available.
<p>
<hr><h3><a name="pdf-os.exit"><code>os.exit ([code [, close]])</code></a></h3>
<p>
Calls the ISO C function <code>exit</code> to terminate the host program.
If <code>code</code> is <b>true</b>,
the returned status is <code>EXIT_SUCCESS</code>;
if <code>code</code> is <b>false</b>,
the returned status is <code>EXIT_FAILURE</code>;
if <code>code</code> is a number,
the returned status is this number.
The default value for <code>code</code> is <b>true</b>.
<p>
If the optional second argument <code>close</code> is true,
closes the Lua state before exiting.
<p>
<hr><h3><a name="pdf-os.getenv"><code>os.getenv (varname)</code></a></h3>
<p>
Returns the value of the process environment variable <code>varname</code>
or <b>fail</b> if the variable is not defined.
<p>
<hr><h3><a name="pdf-os.remove"><code>os.remove (filename)</code></a></h3>
<p>
Deletes the file (or empty directory, on POSIX systems)
with the given name.
If this function fails, it returns <b>fail</b>
plus a string describing the error and the error code.
Otherwise, it returns true.
<p>
<hr><h3><a name="pdf-os.rename"><code>os.rename (oldname, newname)</code></a></h3>
<p>
Renames the file or directory named <code>oldname</code> to <code>newname</code>.
If this function fails, it returns <b>fail</b>,
plus a string describing the error and the error code.
Otherwise, it returns true.
<p>
<hr><h3><a name="pdf-os.setlocale"><code>os.setlocale (locale [, category])</code></a></h3>
<p>
Sets the current locale of the program.
<code>locale</code> is a system-dependent string specifying a locale;
<code>category</code> is an optional string describing which category to change:
<code>"all"</code>, <code>"collate"</code>, <code>"ctype"</code>,
<code>"monetary"</code>, <code>"numeric"</code>, or <code>"time"</code>;
the default category is <code>"all"</code>.
The function returns the name of the new locale,
or <b>fail</b> if the request cannot be honored.
<p>
If <code>locale</code> is the empty string,
the current locale is set to an implementation-defined native locale.
If <code>locale</code> is the string "<code>C</code>",
the current locale is set to the standard C locale.
<p>
When called with <b>nil</b> as the first argument,
this function only returns the name of the current locale
for the given category.
<p>
This function may be not thread safe
because of its reliance on C function <code>setlocale</code>.
<p>
<hr><h3><a name="pdf-os.time"><code>os.time ([table])</code></a></h3>
<p>
Returns the current time when called without arguments,
or a time representing the local date and time specified by the given table.
This table must have fields <code>year</code>, <code>month</code>, and <code>day</code>,
and may have fields
<code>hour</code> (default is 12),
<code>min</code> (default is 0),
<code>sec</code> (default is 0),
and <code>isdst</code> (default is <b>nil</b>).
Other fields are ignored.
For a description of these fields, see the <a href="#pdf-os.date"><code>os.date</code></a> function.
<p>
When the function is called,
the values in these fields do not need to be inside their valid ranges.
For instance, if <code>sec</code> is -10,
it means 10 seconds before the time specified by the other fields;
if <code>hour</code> is 1000,
it means 1000 hours after the time specified by the other fields.
<p>
The returned value is a number, whose meaning depends on your system.
In POSIX, Windows, and some other systems,
this number counts the number
of seconds since some given start time (the "epoch").
In other systems, the meaning is not specified,
and the number returned by <code>time</code> can be used only as an argument to
<a href="#pdf-os.date"><code>os.date</code></a> and <a href="#pdf-os.difftime"><code>os.difftime</code></a>.
<p>
When called with a table,
<code>os.time</code> also normalizes all the fields
documented in the <a href="#pdf-os.date"><code>os.date</code></a> function,
so that they represent the same time as before the call
but with values inside their valid ranges.
<p>
<hr><h3><a name="pdf-os.tmpname"><code>os.tmpname ()</code></a></h3>
<p>
Returns a string with a file name that can
be used for a temporary file.
The file must be explicitly opened before its use
and explicitly removed when no longer needed.
<p>
In POSIX systems,
this function also creates a file with that name,
to avoid security risks.
(Someone else might create the file with wrong permissions
in the time between getting the name and creating the file.)
You still have to open the file to use it
and to remove it (even if you do not use it).
<p>
When possible,
you may prefer to use <a href="#pdf-io.tmpfile"><code>io.tmpfile</code></a>,
which automatically removes the file when the program ends.
<h2>6.10 – <a name="6.10">The Debug Library</a></h2>
<p>
This library provides
the functionality of the debug interface (<a href="#4.7">§4.7</a>) to Lua programs.
You should exert care when using this library.
Several of its functions
violate basic assumptions about Lua code
(e.g., that variables local to a function
cannot be accessed from outside;
that userdata metatables cannot be changed by Lua code;
that Lua programs do not crash)
and therefore can compromise otherwise secure code.
Moreover, some functions in this library may be slow.
<p>
All functions in this library are provided
inside the <a name="pdf-debug"><code>debug</code></a> table.
All functions that operate over a thread
have an optional first argument which is the
thread to operate over.
The default is always the current thread.
<p>
<hr><h3><a name="pdf-debug.debug"><code>debug.debug ()</code></a></h3>
<p>
Enters an interactive mode with the user,
running each string that the user enters.
Using simple commands and other debug facilities,
the user can inspect global and local variables,
change their values, evaluate expressions, and so on.
A line containing only the word <code>cont</code> finishes this function,
so that the caller continues its execution.
<p>
Note that commands for <code>debug.debug</code> are not lexically nested
within any function and so have no direct access to local variables.
<p>
<hr><h3><a name="pdf-debug.gethook"><code>debug.gethook ([thread])</code></a></h3>
<p>
Returns the current hook settings of the thread, as three values:
the current hook function, the current hook mask,
and the current hook count,
as set by the <a href="#pdf-debug.sethook"><code>debug.sethook</code></a> function.
<p>
Returns <b>fail</b> if there is no active hook.
<p>
<hr><h3><a name="pdf-debug.getinfo"><code>debug.getinfo ([thread,] f [, what])</code></a></h3>
<p>
Returns a table with information about a function.
You can give the function directly
or you can give a number as the value of <code>f</code>,
which means the function running at level <code>f</code> of the call stack
of the given thread:
level 0 is the current function (<code>getinfo</code> itself);
level 1 is the function that called <code>getinfo</code>
(except for tail calls, which do not count in the stack);
and so on.
If <code>f</code> is a number greater than the number of active functions,
then <code>getinfo</code> returns <b>fail</b>.
<p>
The returned table can contain all the fields returned by <a href="#lua_getinfo"><code>lua_getinfo</code></a>,
with the string <code>what</code> describing which fields to fill in.
The default for <code>what</code> is to get all information available,
except the table of valid lines.
If present,
the option '<code>f</code>'
adds a field named <code>func</code> with the function itself.
If present,
the option '<code>L</code>'
adds a field named <code>activelines</code> with the table of
valid lines.
<p>
For instance, the expression <code>debug.getinfo(1,"n").name</code> returns
a name for the current function,
if a reasonable name can be found,
and the expression <code>debug.getinfo(print)</code>
returns a table with all available information
about the <a href="#pdf-print"><code>print</code></a> function.
<p>
<hr><h3><a name="pdf-debug.getlocal"><code>debug.getlocal ([thread,] f, local)</code></a></h3>
<p>
This function returns the name and the value of the local variable
with index <code>local</code> of the function at level <code>f</code> of the stack.
This function accesses not only explicit local variables,
but also parameters and temporary values.
<p>
The first parameter or local variable has index 1, and so on,
following the order that they are declared in the code,
counting only the variables that are active
in the current scope of the function.
Compile-time constants may not appear in this listing,
if they were optimized away by the compiler.
Negative indices refer to vararg arguments;
-1 is the first vararg argument.
The function returns <b>fail</b>
if there is no variable with the given index,
and raises an error when called with a level out of range.
(You can call <a href="#pdf-debug.getinfo"><code>debug.getinfo</code></a> to check whether the level is valid.)
<p>
Variable names starting with '<code>(</code>' (open parenthesis)
represent variables with no known names
(internal variables such as loop control variables,
and variables from chunks saved without debug information).
<p>
The parameter <code>f</code> may also be a function.
In that case, <code>getlocal</code> returns only the name of function parameters.
<p>
<hr><h3><a name="pdf-debug.getmetatable"><code>debug.getmetatable (value)</code></a></h3>
<p>
Returns the metatable of the given <code>value</code>
or <b>nil</b> if it does not have a metatable.
<p>
<hr><h3><a name="pdf-debug.getregistry"><code>debug.getregistry ()</code></a></h3>
<p>
Returns the registry table (see <a href="#4.3">§4.3</a>).
<p>
<hr><h3><a name="pdf-debug.getupvalue"><code>debug.getupvalue (f, up)</code></a></h3>
<p>
This function returns the name and the value of the upvalue
with index <code>up</code> of the function <code>f</code>.
The function returns <b>fail</b>
if there is no upvalue with the given index.
<p>
(For Lua functions,
upvalues are the external local variables that the function uses,
and that are consequently included in its closure.)
<p>
For C functions, this function uses the empty string <code>""</code>
as a name for all upvalues.
<p>
Variable name '<code>?</code>' (interrogation mark)
represents variables with no known names
(variables from chunks saved without debug information).
<p>
<hr><h3><a name="pdf-debug.getuservalue"><code>debug.getuservalue (u, n)</code></a></h3>
<p>
Returns the <code>n</code>-th user value associated
to the userdata <code>u</code> plus a boolean,
<b>false</b> if the userdata does not have that value.
<p>
<hr><h3><a name="pdf-debug.sethook"><code>debug.sethook ([thread,] hook, mask [, count])</code></a></h3>
<p>
Sets the given function as the debug hook.
The string <code>mask</code> and the number <code>count</code> describe
when the hook will be called.
The string mask may have any combination of the following characters,
with the given meaning:
<ul>
<li><b>'<code>c</code>': </b> the hook is called every time Lua calls a function;</li>
<li><b>'<code>r</code>': </b> the hook is called every time Lua returns from a function;</li>
<li><b>'<code>l</code>': </b> the hook is called every time Lua enters a new line of code.</li>
</ul><p>
Moreover,
with a <code>count</code> different from zero,
the hook is called also after every <code>count</code> instructions.
<p>
When called without arguments,
<a href="#pdf-debug.sethook"><code>debug.sethook</code></a> turns off the hook.
<p>
When the hook is called, its first parameter is a string
describing the event that has triggered its call:
<code>"call"</code>, <code>"tail call"</code>, <code>"return"</code>,
<code>"line"</code>, and <code>"count"</code>.
For line events,
the hook also gets the new line number as its second parameter.
Inside a hook,
you can call <code>getinfo</code> with level 2 to get more information about
the running function.
(Level 0 is the <code>getinfo</code> function,
and level 1 is the hook function.)
<p>
<hr><h3><a name="pdf-debug.setlocal"><code>debug.setlocal ([thread,] level, local, value)</code></a></h3>
<p>
This function assigns the value <code>value</code> to the local variable
with index <code>local</code> of the function at level <code>level</code> of the stack.
The function returns <b>fail</b> if there is no local
variable with the given index,
and raises an error when called with a <code>level</code> out of range.
(You can call <code>getinfo</code> to check whether the level is valid.)
Otherwise, it returns the name of the local variable.
<p>
See <a href="#pdf-debug.getlocal"><code>debug.getlocal</code></a> for more information about
variable indices and names.
<p>
<hr><h3><a name="pdf-debug.setmetatable"><code>debug.setmetatable (value, table)</code></a></h3>
<p>
Sets the metatable for the given <code>value</code> to the given <code>table</code>
(which can be <b>nil</b>).
Returns <code>value</code>.
<p>
<hr><h3><a name="pdf-debug.setupvalue"><code>debug.setupvalue (f, up, value)</code></a></h3>
<p>
This function assigns the value <code>value</code> to the upvalue
with index <code>up</code> of the function <code>f</code>.
The function returns <b>fail</b> if there is no upvalue
with the given index.
Otherwise, it returns the name of the upvalue.
<p>
See <a href="#pdf-debug.getupvalue"><code>debug.getupvalue</code></a> for more information about upvalues.
<p>
<hr><h3><a name="pdf-debug.setuservalue"><code>debug.setuservalue (udata, value, n)</code></a></h3>
<p>
Sets the given <code>value</code> as
the <code>n</code>-th user value associated to the given <code>udata</code>.
<code>udata</code> must be a full userdata.
<p>
Returns <code>udata</code>,
or <b>fail</b> if the userdata does not have that value.
<p>
<hr><h3><a name="pdf-debug.traceback"><code>debug.traceback ([thread,] [message [, level]])</code></a></h3>
<p>
If <code>message</code> is present but is neither a string nor <b>nil</b>,
this function returns <code>message</code> without further processing.
Otherwise,
it returns a string with a traceback of the call stack.
The optional <code>message</code> string is appended
at the beginning of the traceback.
An optional <code>level</code> number tells at which level
to start the traceback
(default is 1, the function calling <code>traceback</code>).
<p>
<hr><h3><a name="pdf-debug.upvalueid"><code>debug.upvalueid (f, n)</code></a></h3>
<p>
Returns a unique identifier (as a light userdata)
for the upvalue numbered <code>n</code>
from the given function.
<p>
These unique identifiers allow a program to check whether different
closures share upvalues.
Lua closures that share an upvalue
(that is, that access a same external local variable)
will return identical ids for those upvalue indices.
<p>
<hr><h3><a name="pdf-debug.upvaluejoin"><code>debug.upvaluejoin (f1, n1, f2, n2)</code></a></h3>
<p>
Make the <code>n1</code>-th upvalue of the Lua closure <code>f1</code>
refer to the <code>n2</code>-th upvalue of the Lua closure <code>f2</code>.
<h1>7 – <a name="7">Lua Standalone</a></h1>
<p>
Although Lua has been designed as an extension language,
to be embedded in a host C program,
it is also frequently used as a standalone language.
An interpreter for Lua as a standalone language,
called simply <code>lua</code>,
is provided with the standard distribution.
The standalone interpreter includes
all standard libraries.
Its usage is:
<pre>
lua [options] [script [args]]
</pre><p>
The options are:
<ul>
<li><b><code>-e <em>stat</em></code>: </b> execute string <em>stat</em>;</li>
<li><b><code>-i</code>: </b> enter interactive mode after running <em>script</em>;</li>
<li><b><code>-l <em>mod</em></code>: </b> "require" <em>mod</em> and assign the
result to global <em>mod</em>;</li>
<li><b><code>-v</code>: </b> print version information;</li>
<li><b><code>-E</code>: </b> ignore environment variables;</li>
<li><b><code>-W</code>: </b> turn warnings on;</li>
<li><b><code>--</code>: </b> stop handling options;</li>
<li><b><code>-</code>: </b> execute <code>stdin</code> as a file and stop handling options.</li>
</ul><p>
After handling its options, <code>lua</code> runs the given <em>script</em>.
When called without arguments,
<code>lua</code> behaves as <code>lua -v -i</code>
when the standard input (<code>stdin</code>) is a terminal,
and as <code>lua -</code> otherwise.
<p>
When called without the option <code>-E</code>,
the interpreter checks for an environment variable <a name="pdf-LUA_INIT_5_4"><code>LUA_INIT_5_4</code></a>
(or <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a> if the versioned name is not defined)
before running any argument.
If the variable content has the format <code>@<em>filename</em></code>,
then <code>lua</code> executes the file.
Otherwise, <code>lua</code> executes the string itself.
<p>
When called with the option <code>-E</code>,
Lua does not consult any environment variables.
In particular,
the values of <a href="#pdf-package.path"><code>package.path</code></a> and <a href="#pdf-package.cpath"><code>package.cpath</code></a>
are set with the default paths defined in <code>luaconf.h</code>.
<p>
The options <code>-e</code>, <code>-l</code>, and <code>-W</code> are handled in
the order they appear.
For instance, an invocation like
<pre>
$ lua -e 'a=1' -llib1 script.lua
</pre><p>
will first set <code>a</code> to 1, then require the library <code>lib1</code>,
and finally run the file <code>script.lua</code> with no arguments.
(Here <code>$</code> is the shell prompt. Your prompt may be different.)
<p>
Before running any code,
<code>lua</code> collects all command-line arguments
in a global table called <code>arg</code>.
The script name goes to index 0,
the first argument after the script name goes to index 1,
and so on.
Any arguments before the script name
(that is, the interpreter name plus its options)
go to negative indices.
For instance, in the call
<pre>
$ lua -la b.lua t1 t2
</pre><p>
the table is like this:
<pre>
arg = { [-2] = "lua", [-1] = "-la",
[0] = "b.lua",
[1] = "t1", [2] = "t2" }
</pre><p>
If there is no script in the call,
the interpreter name goes to index 0,
followed by the other arguments.
For instance, the call
<pre>
$ lua -e "print(arg[1])"
</pre><p>
will print "<code>-e</code>".
If there is a script,
the script is called with arguments
<code>arg[1]</code>, ···, <code>arg[#arg]</code>.
Like all chunks in Lua,
the script is compiled as a vararg function.
<p>
In interactive mode,
Lua repeatedly prompts and waits for a line.
After reading a line,
Lua first try to interpret the line as an expression.
If it succeeds, it prints its value.
Otherwise, it interprets the line as a statement.
If you write an incomplete statement,
the interpreter waits for its completion
by issuing a different prompt.
<p>
If the global variable <a name="pdf-_PROMPT"><code>_PROMPT</code></a> contains a string,
then its value is used as the prompt.
Similarly, if the global variable <a name="pdf-_PROMPT2"><code>_PROMPT2</code></a> contains a string,
its value is used as the secondary prompt
(issued during incomplete statements).
<p>
In case of unprotected errors in the script,
the interpreter reports the error to the standard error stream.
If the error object is not a string but
has a metamethod <code>__tostring</code>,
the interpreter calls this metamethod to produce the final message.
Otherwise, the interpreter converts the error object to a string
and adds a stack traceback to it.
When warnings are on,
they are simply printed in the standard error output.
<p>
When finishing normally,
the interpreter closes its main Lua state
(see <a href="#lua_close"><code>lua_close</code></a>).
The script can avoid this step by
calling <a href="#pdf-os.exit"><code>os.exit</code></a> to terminate.
<p>
To allow the use of Lua as a
script interpreter in Unix systems,
Lua skips the first line of a file chunk if it starts with <code>#</code>.
Therefore, Lua scripts can be made into executable programs
by using <code>chmod +x</code> and the <code>#!</code> form,
as in
<pre>
#!/usr/local/bin/lua
</pre><p>
Of course,
the location of the Lua interpreter may be different in your machine.
If <code>lua</code> is in your <code>PATH</code>,
then
<pre>
#!/usr/bin/env lua
</pre><p>
is a more portable solution.
<h1>8 – <a name="8">Incompatibilities with the Previous Version</a></h1>
<p>
Here we list the incompatibilities that you may find when moving a program
from Lua 5.3 to Lua 5.4.
<p>
You can avoid some incompatibilities by compiling Lua with
appropriate options (see file <code>luaconf.h</code>).
However,
all these compatibility options will be removed in the future.
More often than not,
compatibility issues arise when these compatibility options
are removed.
So, whenever you have the chance,
you should try to test your code with a version of Lua compiled
with all compatibility options turned off.
That will ease transitions to newer versions of Lua.
<p>
Lua versions can always change the C API in ways that
do not imply source-code changes in a program,
such as the numeric values for constants
or the implementation of functions as macros.
Therefore,
you should never assume that binaries are compatible between
different Lua versions.
Always recompile clients of the Lua API when
using a new version.
<p>
Similarly, Lua versions can always change the internal representation
of precompiled chunks;
precompiled chunks are not compatible between different Lua versions.
<p>
The standard paths in the official distribution may
change between versions.
<h2>8.1 – <a name="8.1">Incompatibilities in the Language</a></h2>
<ul>
<li>
The coercion of strings to numbers in
arithmetic and bitwise operations
has been removed from the core language.
The string library does a similar job
for arithmetic (but not for bitwise) operations
using the string metamethods.
However, unlike in previous versions,
the new implementation preserves the implicit type of the numeral
in the string.
For instance, the result of <code>"1" + "2"</code> now is an integer,
not a float.
</li>
<li>
Literal decimal integer constants that overflow are read as floats,
instead of wrapping around.
You can use hexadecimal notation for such constants if you
want the old behavior
(reading them as integers with wrap around).
</li>
<li>
The use of the <code>__lt</code> metamethod to emulate <code>__le</code>
has been removed.
When needed, this metamethod must be explicitly defined.
</li>
<li>
The semantics of the numerical <b>for</b> loop
over integers changed in some details.
In particular, the control variable never wraps around.
</li>
<li>
A label for a <b>goto</b> cannot be declared where a label with the same
name is visible, even if this other label is declared in an enclosing
block.
</li>
<li>
When finalizing an object,
Lua does not ignore <code>__gc</code> metamethods that are not functions.
Any value will be called, if present.
(Non-callable values will generate a warning,
like any other error when calling a finalizer.)
</li>
</ul>
<h2>8.2 – <a name="8.2">Incompatibilities in the Libraries</a></h2>
<ul>
<li>
The function <a href="#pdf-print"><code>print</code></a> does not call <a href="#pdf-tostring"><code>tostring</code></a>
to format its arguments;
instead, it has this functionality hardwired.
You should use <code>__tostring</code> to modify how values are printed.
</li>
<li>
The pseudo-random number generator used by the function <a href="#pdf-math.random"><code>math.random</code></a>
now starts with a somewhat random seed.
Moreover, it uses a different algorithm.
</li>
<li>
By default, the decoding functions in the <a href="#pdf-utf8"><code>utf8</code></a> library
do not accept surrogates as valid code points.
An extra parameter in these functions makes them more permissive.
</li>
<li>
The options "<code>setpause</code>" and "<code>setstepmul</code>"
of the function <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> are deprecated.
You should use the new option "<code>incremental</code>" to set them.
</li>
<li>
The function <a href="#pdf-io.lines"><code>io.lines</code></a> now returns four values,
instead of just one.
That can be a problem when it is used as the sole
argument to another function that has optional parameters,
such as in <code>load(io.lines(filename, "L"))</code>.
To fix that issue,
you can wrap the call into parentheses,
to adjust its number of results to one.
</li>
</ul>
<h2>8.3 – <a name="8.3">Incompatibilities in the API</a></h2>
<ul>
<li>
Full userdata now has an arbitrary number of associated user values.
Therefore, the functions <code>lua_newuserdata</code>,
<code>lua_setuservalue</code>, and <code>lua_getuservalue</code> were
replaced by <a href="#lua_newuserdatauv"><code>lua_newuserdatauv</code></a>,
<a href="#lua_setiuservalue"><code>lua_setiuservalue</code></a>, and <a href="#lua_getiuservalue"><code>lua_getiuservalue</code></a>,
which have an extra argument.
<p>
For compatibility, the old names still work as macros assuming
one single user value.
Note, however, that userdata with zero user values
are more efficient memory-wise.
</li>
<li>
The function <a href="#lua_resume"><code>lua_resume</code></a> has an extra parameter.
This out parameter returns the number of values on
the top of the stack that were yielded or returned by the coroutine.
(In previous versions,
those values were the entire stack.)
</li>
<li>
The function <a href="#lua_version"><code>lua_version</code></a> returns the version number,
instead of an address of the version number.
The Lua core should work correctly with libraries using their
own static copies of the same core,
so there is no need to check whether they are using the same
address space.
</li>
<li>
The constant <code>LUA_ERRGCMM</code> was removed.
Errors in finalizers are never propagated;
instead, they generate a warning.
</li>
<li>
The options <code>LUA_GCSETPAUSE</code> and <code>LUA_GCSETSTEPMUL</code>
of the function <a href="#lua_gc"><code>lua_gc</code></a> are deprecated.
You should use the new option <code>LUA_GCINC</code> to set them.
</li>
</ul>
<h1>9 – <a name="9">The Complete Syntax of Lua</a></h1>
<p>
Here is the complete syntax of Lua in extended BNF.
As usual in extended BNF,
{A} means 0 or more As,
and [A] means an optional A.
(For operator precedences, see <a href="#3.4.8">§3.4.8</a>;
for a description of the terminals
Name, Numeral,
and LiteralString, see <a href="#3.1">§3.1</a>.)
<pre>
chunk ::= block
block ::= {stat} [retstat]
stat ::= ‘<b>;</b>’ |
varlist ‘<b>=</b>’ explist |
functioncall |
label |
<b>break</b> |
<b>goto</b> Name |
<b>do</b> block <b>end</b> |
<b>while</b> exp <b>do</b> block <b>end</b> |
<b>repeat</b> block <b>until</b> exp |
<b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b> |
<b>for</b> Name ‘<b>=</b>’ exp ‘<b>,</b>’ exp [‘<b>,</b>’ exp] <b>do</b> block <b>end</b> |
<b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b> |
<b>function</b> funcname funcbody |
<b>local</b> <b>function</b> Name funcbody |
<b>local</b> attnamelist [‘<b>=</b>’ explist]
attnamelist ::= Name attrib {‘<b>,</b>’ Name attrib}
attrib ::= [‘<b><</b>’ Name ‘<b>></b>’]
retstat ::= <b>return</b> [explist] [‘<b>;</b>’]
label ::= ‘<b>::</b>’ Name ‘<b>::</b>’
funcname ::= Name {‘<b>.</b>’ Name} [‘<b>:</b>’ Name]
varlist ::= var {‘<b>,</b>’ var}
var ::= Name | prefixexp ‘<b>[</b>’ exp ‘<b>]</b>’ | prefixexp ‘<b>.</b>’ Name
namelist ::= Name {‘<b>,</b>’ Name}
explist ::= exp {‘<b>,</b>’ exp}
exp ::= <b>nil</b> | <b>false</b> | <b>true</b> | Numeral | LiteralString | ‘<b>...</b>’ | functiondef |
prefixexp | tableconstructor | exp binop exp | unop exp
prefixexp ::= var | functioncall | ‘<b>(</b>’ exp ‘<b>)</b>’
functioncall ::= prefixexp args | prefixexp ‘<b>:</b>’ Name args
args ::= ‘<b>(</b>’ [explist] ‘<b>)</b>’ | tableconstructor | LiteralString
functiondef ::= <b>function</b> funcbody
funcbody ::= ‘<b>(</b>’ [parlist] ‘<b>)</b>’ block <b>end</b>
parlist ::= namelist [‘<b>,</b>’ ‘<b>...</b>’] | ‘<b>...</b>’
tableconstructor ::= ‘<b>{</b>’ [fieldlist] ‘<b>}</b>’
fieldlist ::= field {fieldsep field} [fieldsep]
field ::= ‘<b>[</b>’ exp ‘<b>]</b>’ ‘<b>=</b>’ exp | Name ‘<b>=</b>’ exp | exp
fieldsep ::= ‘<b>,</b>’ | ‘<b>;</b>’
binop ::= ‘<b>+</b>’ | ‘<b>-</b>’ | ‘<b>*</b>’ | ‘<b>/</b>’ | ‘<b>//</b>’ | ‘<b>^</b>’ | ‘<b>%</b>’ |
‘<b>&</b>’ | ‘<b>~</b>’ | ‘<b>|</b>’ | ‘<b>>></b>’ | ‘<b><<</b>’ | ‘<b>..</b>’ |
‘<b><</b>’ | ‘<b><=</b>’ | ‘<b>></b>’ | ‘<b>>=</b>’ | ‘<b>==</b>’ | ‘<b>~=</b>’ |
<b>and</b> | <b>or</b>
unop ::= ‘<b>-</b>’ | <b>not</b> | ‘<b>#</b>’ | ‘<b>~</b>’
</pre>
<p>
<P CLASS="footer">
Last update:
Mon Mar 15 13:39:42 UTC 2021
</P>
<!--
Last change: revised for Lua 5.4.3
-->
</body></html>
``` |
The Defense Intelligence Agency (DIA) is an intelligence agency and combat support agency of the United States Department of Defense, specializing in defense and military intelligence.
A component of the Department of Defense (DoD) and the Intelligence Community (IC), DIA informs national civilian and defense policymakers about the military intentions and capabilities of foreign governments and non-state actors. It also provides intelligence assistance, integration and coordination across uniformed military service intelligence components, which remain structurally separate from DIA. The agency's role encompasses the collection and analysis of military-related foreign political, economic, industrial, geographic, and medical and health intelligence. DIA produces approximately one-quarter of all intelligence content that goes into the President's Daily Brief.
DIA's intelligence operations extend beyond the zones of combat, and approximately half of its employees serve overseas at hundreds of locations and in U.S. embassies in 140 countries. The agency specializes in the collection and analysis of human-source intelligence (HUMINT), both overt and clandestine, while also handling U.S. military-diplomatic relations abroad. DIA concurrently serves as the national manager for the highly technical measurement and signature intelligence (MASINT) and as the Defense Department manager for counterintelligence programs. The agency has no law enforcement authority, contrary to occasional portrayals in American popular culture.
DIA is a national-level intelligence organization that does not belong to a single military element or within the traditional chain of command, instead answering to the Secretary of Defense directly through the Under Secretary of Defense for Intelligence. Three-quarters of the agency's 17,000 employees are career civilians who are experts in various fields of defense and military interest or application; and although no military background is required, 48% of agency employees have some past military service. DIA has a tradition of marking unclassified deaths of its employees on the organization's Memorial Wall.
Established in 1961 under President John F. Kennedy by Defense Secretary Robert McNamara, DIA was involved in U.S. intelligence efforts throughout the Cold War and rapidly expanded, both in size and scope, after the September 11 attacks. Because of the sensitive nature of its work, the spy organization has been embroiled in numerous controversies, including those related to its intelligence-gathering activities, to its role in torture, as well as to attempts to expand its activities on U.S. soil.
Overview
The Director of the Defense Intelligence Agency is an intelligence officer who is nominated by the President and confirmed by the Senate. He or she is the primary intelligence adviser to the Secretary of Defense and also answers to the Director of National Intelligence. The Director is also the Commander of the Joint Functional Component Command for Intelligence, Surveillance and Reconnaissance, a subordinate command of United States Strategic Command, which is headquartered in Omaha, Nebraska. Additionally, he or she chairs the Military Intelligence Board, which coordinates activities of the entire defense intelligence community.
DIA is headquartered in Washington, D.C., on Joint Base Anacostia–Bolling with major operational activities at the Pentagon and at each Unified Combatant Command, as well as in more than a hundred U.S. embassies around the world, where it deploys alongside other government partners (e.g., the CIA) and also operates the U.S. Defense Attache Offices. Additionally, the agency has staff deployed at the Col. James N. Rowe Building at Rivanna Station in Charlottesville, Virginia, National Center for Medical Intelligence (NCMI) in Fort Detrick, Maryland, Missile and Space Intelligence Center (MSIC) in Huntsville, Alabama, Russell-Knox Building on Marine Corps Base Quantico, National Center for Credibility Assessment at Fort Jackson, South Carolina, and Defense Intelligence Support Center (DISC) in Reston, Virginia. DIA also recently completed the renovation of Intelligence Community Campus-Bethesda in Maryland, which serves as the new location of the National Intelligence University as well as a facility for DIA and the Office of the Director of National Intelligence.
Less known than its civilian equivalent or its cryptologic counterpart, DIA and its personnel have at times been portrayed in works of American popular culture. As with other U.S. foreign intelligence organizations, the agency's role has occasionally been confused with those of law enforcement agencies. DIA's parent organization, the Department of Defense, features in fiction and media much more prominently due to the public's greater awareness of its existence and the general association of military organizations with warfare, rather than spycraft.
Comparison to other intelligence community members
CIA
DIA and the Central Intelligence Agency (CIA) are distinct organizations with different functions. DIA focuses on national level defense-military topics, while CIA is concentrated on broader, more general intelligence needs of the President and Cabinet. Additionally, due to DIA's designation as a combat support agency, it has special responsibilities in meeting intelligence requirements specifically for the Secretary of Defense, the Joint Chiefs of Staff, and Combatant Commanders, both in peace and at war. Although there are misconceptions in the media and public about the DIA–CIA rivalry, the two agencies have a mutually beneficial relationship and division of labor. According to a former senior U.S official who worked with both agencies, "the CIA doesn't want to be looking for surface-to-air missiles in Libya" while it is also tasked with evaluating the Syrian opposition. CIA and DIA Operations Officers all go through the same type of clandestine training at an interagency Defense installation under CIA administration, best known in popular culture by its CIA nickname "The Farm".
DIA and the military services
DIA is not a collective of all U.S. military intelligence units and the work it performs is not in lieu of that falling under intelligence components of individual services. Unlike the Russian GRU, which encompasses equivalents of nearly all joint U.S. military intelligence operations, DIA assists and coordinates the activities of individual service-level intelligence units (i.e. 25 AF, INSCOM, etc.), but they nevertheless remain separate entities. As a general rule, DIA handles national-level, long-term and strategic intelligence needs, whereas service-level intelligence components handle tactical, short-term goals pertinent to their respective services. DIA does, however, lead coordination efforts with the military intelligence units and with the national DOD intelligence services (NSA, NGA, NRO) in its role as chair of the Military Intelligence Board and through the co-located Joint Functional Component Command for Intelligence, Surveillance and Reconnaissance.
Organization
DIA is organized into four directorates and five regional centers
Directorate for Operations:
Defense Clandestine Service (DCS): DCS conducts clandestine espionage activities around the world and is the executive agent for human intelligence operations throughout the Department of Defense. Staffed by civilian and military personnel, the DCS is a consolidation of the former Defense Human Intelligence Service and works in conjunction with the Central Intelligence Agency's Directorate of Operations, among other national HUMINT entities. It globally deploys teams of case officers, interrogation experts, field analysts, linguists, technical specialists, and special operations forces.
Defense Attache System (DAS): DAS represents the United States in defense and military-diplomatic relations with foreign governments worldwide. It also manages and conducts overt human intelligence collection activities. Defense Attaches serve from Defense Attache Offices (DAO) co-located at more than a hundred United States Embassies in foreign nations, represent the Secretary of Defense in diplomatic relations with foreign governments and militaries, and coordinate military activities with partner nations.
Defense Cover Office (DCO): DCO is a DIA component responsible for executing cover programs for agency's intelligence officers, as well as those for the entire Department of Defense.
Directorate for Analysis: The Directorate of Analysis manages the all-source analysis elements of DIA, and is responsible for developing and deploying analytic tradecraft throughout the Defense Intelligence Enterprise. Analysts analyze and disseminate finalized intelligence products, focusing on national, strategic and operational-level military issues that may arise from worldwide political, economic, medical, natural or other related processes. Analysts contribute to the President's Daily Brief and the National Intelligence Estimates. Analysts serve DIA in all of the agency's facilities and DIA has the most forward deployed analysts in the Intelligence Community.
Directorate for Science and Technology: The Directorate for Science and Technology manages DIA's technical assets and personnel. These assets gather and analyze Measurement and Signature Intelligence, which is a technical intelligence discipline that serves to detect, track, identify or describe the signatures (distinctive characteristics) of fixed or dynamic target sources. This often includes radar intelligence, acoustic intelligence, nuclear intelligence, and chemical and biological intelligence. DIA is designated the national manager for MASINT collection within the United States Intelligence Community, coordinating all MASINT gathering across agencies. DIA is also the national manager of the Joint Worldwide Intelligence Communications System (JWICS), the central Top Secret/Sensitive Compartmented Information (TS/SCI) processing network for the United States, and Stone Ghost, a network for US and partner nations.
Directorate for Mission Services: The Directorate for Mission Services provides administrative, technical, and programmatic support to the agency's domestic and global operations and analytic efforts. This includes providing counterintelligence to the agency as well as serving as the counterintelligence executive agent for the Department of Defense.
Centers: DIA is divided into five regional centers and two functional center which manage the agency's efforts in these areas of responsibility. These centers are the Americas and Transnational Threats Center, the Indo-Pacific Regional Center, the Europe/Eurasia Regional Center, the Middle East/Africa Regional Center, the China Mission Group, the Defense Resources and Infrastructure Center, and the Defense Combating Terrorism Center. DIA also manages Community-wide centers such as the National Center for Medical Intelligence, the Missile and Space Intelligence Center, the National Media Exploitation Center, and the Underground Facilities Analysis Center (UFAC).
Further, DIA is responsible for administering the JIOCEUR and various Joint Intelligence Centers which serve and are co-located with each of the Unified Combatant Commands. Additionally, DIA manages the Directorate for Intelligence, Joint Staff (J2) which advises and supports the Joint Chiefs of Staff with foreign military intelligence for defense policy and war planning.
DIA also manages the National Intelligence University (NIU) on behalf of the Intelligence Community. NIU and the John T. Hughes Library is housed at the Intelligence Community campus in Bethesda, Maryland and has several branch campuses at RAF Molesworth, MacDill Air Force Base, and Marine Corps Base Quantico as well as academic programs at the NSA and NGA.
DIA Police
The DIA has its own police force (established in 1963), made up of federal officers who protect DIA people and property. DIA Police provide law enforcement and police services, emergency response and physical security at DIA campuses.
DIA Police have 170 sworn, uniformed officers that protect and police the six DIA sites (Headquarters, Reston, Charlottesville, DIA Logistics Operation Center, National Center for Medical Intelligence and Missile and Space Intelligence Center).
DIA Police has 26 Special Agents that carry out security investigations.
Training
DIA Police Officers are trained at the Federal Law Enforcement Training Center for three months before being certified.
Authority
DIA Police operate under the U.S. Marshal's Office Special Deputation and jurisdictional and functional authority within the District of Columbia under a cooperative agreement with the Metropolitan Police Department of the District of Columbia.
Rank structure and organization
DIA Police have the following rank structure:
Officer
Special Agent (investigations)
Sergeant
Captain
DIA Police have K9, HAZMAT, SRT and also support DIA field operations.
Employment requirements and polygraph
Due to the sensitive nature of DIA's work, all of its personnel, including interns and contractors, are subject to the same security standards and must obtain a Top Secret clearance with Sensitive Compartmented Information (TS/SCI) access. Collateral Top Secret clearances granted by the DoD are not sufficient to grant access to DIA's SCI information. Additionally, the SCI access granted by other intelligence agencies, such as CIA or NSA, do not transfer to DIA and vice versa.
In addition to the rigorous background investigations, psychological and drug screening, as well as security interviews, DIA requires that its applicants pass the agency polygraph. In fact, DIA exercises operational control over the National Center for Credibility Assessment (NCCA), which establishes polygraphing standards and trains polygraphers for placement across the entire intelligence community. In 2008, the agency started expanding its polygraph program in an attempt to screen 5,700 prospective and current employees every year. This was a several fold increase from 2002 when, according to information provided to Congress, DIA conducted 1,345 polygraphs. According to the unclassified DIA document cited in the news report, since the mid-2000s the agency started hiring contract polygraphers in addition to the permanent DIA polygraphers and added 13 polygraphing studios to those the spy organization already operated. This expanded polygraph screening at DIA continued notwithstanding documented technical problems discovered in the Lafayette computerized polygraph system used by the agency; the organization allegedly refused to change the flawed Lafayette polygraph but declined to comment as to the reasoning.
Unlike the CIA and NSA polygraphs, DIA polygraphs are only of Counterintelligence Scope (CI), rather than Full Scope (FS) (also known as Expanded Scope Screening or ESS), which is ostensibly more intrusive as far as one's personal life is concerned. DIA administered only a handful of FS polygraphs and only for those personnel who were to be detailed to the CIA. Additionally, DIA conducted a handful of FS polygraphs on its personnel remaining overseas in excess of 6.5 years, although this practice appeared to be outside the scope of DIA's authorization at the time.
Like with other intelligence agencies, failing to pass the DIA polygraph is a virtual guarantee that an applicant will be judged unsuitable for agency employment. In fact, according to a report published by the Office of the Undersecretary of Defense of Intelligence, while the usually more stringent NSA is willing to give its applicants several shots at passing the polygraph, DIA tends to give one or at most two opportunities to clear the test, after which the employment offer is rescinded. The same report recommended that DIA seek permanent authority to conduct more intrusive Expanded Scope Screenings due to their supposed usefulness in eliciting admissions from applicants.
Similarly to other intelligence agencies, employees are required to take periodic polygraph examinations throughout their careers. However, no unfavorable administrative actions will be taken against them based solely on their results.
Budget and personnel
DIA's budget and exact personnel numbers are classified. Classified Information is not willingly revealed to the public or with anyone that has does not have a need-to-know verified. The agency does reveal that currently, it has approximately 17,000 employees, two-thirds of whom are civilians and approximately 50% of whom work at more than 141 overseas locations. In 1994, it was revealed that DIA requested approximately $4 billion in funding for the period of 1996–2001 ($6.3 billion inflation adjusted), averaging $666 million per year ($1.05 billion inflation adjusted). The agency, however, has nearly doubled in size since then and also assumed additional responsibilities from various intelligence elements from across the Department of Defense, CIA and wider intelligence community. In 2006, at the height of Donald Rumsfeld's push to further expand the scope of military intelligence beyond tactical considerations, DIA was estimated to receive up to $3 billion annually.
According to classified documents leaked by Edward Snowden and published by The Washington Post in 2013, the National Intelligence Program (NIP) component of the overall US intelligence budget contained approximately $4.4 billion/year for the General Defense Intelligence Program (GDIP), which is managed by DIA, even as it is not exclusively for the agency's use. The numbers exclude the Military Intelligence Component (MIP) of the overall US intelligence budget, which by itself has averaged more than $20 billion per year in the past decade.
Notable cases of espionage
DIA is one of a few U.S. federal organizations, such as the CIA and FBI, that rely on human espionage to collect information. For this reason, the agency has been involved in numerous espionage events over the course of decades.
Spying for DIA
Victor Kaliadin () – a CEO of a Russian company "Elers Electron", who in 2001 was sentenced to 14 years in prison for selling a ring run by a DIA agent technical information on Arena, the Russian active protection system for tanks. He died of his fourth heart attack in 2004.
Igor Sutyagin – Russian arms control and nuclear weapons specialist convicted in 2004 of spying for DIA. Released in 2010 in exchange for Russian spies arrested in the U.S. during the break-up of the Illegals Program. Denies any involvement in spying.
Edmond Pope – A retired intelligence officer-turned-"businessman", sentenced by a Russian court in 2000 to 20 years for buying up and smuggling classified military equipment out of the country as scrap metal. He was soon pardoned by newly elected Vladimir Putin but continues to assert that the Russian authorities used him as a scapegoat for their broken system. In the same interview with Larry King, however, he spoke of a plot by unspecified people in the U.S., as part of which Pope was being slowly poisoned in the Lefortovo Prison, with the hopes that he would eventually have to be transferred to a hospital, abducted on his way and smuggled out of the country; he claims that his representatives stopped the plot.
Jerzy Strawa – a Polish engineer and an employee of the Ministry of Foreign Trade executed in 1968 at Mokotów Prison for passing industrial and defense information to DIA agents while on official trips in Austria and West Germany.
Natan Sharansky – a former high ranking Israeli politician and Soviet dissident who, during his life in Russia, was sentenced to 13 years of prison with hard labor for spying for DIA. The prosecution alleged that he gave a DIA agent in journalist's disguise—Robert Toth—a list of people who had access to military and other secrets. Sharansky was released in 1986 following a spy exchange that took place on the Glienicke Bridge between the USSR and the Western allies. In 2006, he was awarded the Presidential Medal of Freedom.
Charles Dennis McKee – a DIA officer who, along with CIA's Matthew Gannon, died as a result of the Pan Am Flight 103 bombing. The incident produced numerous conspiracy theories that the flight was bombed because the officers were aware of illicit U.S. intelligence drug activities or that the case was related to them trying to secure the release of American hostages in Lebanon. He is notably absent from DIA's memorial wall (below)
Spying against DIA
Ana Belén Montes – a senior DIA analyst arrested in 2001 for spying for the G2 of Cuba and sentenced to 25 years in prison. Prosecutors alleged that she started spying in the mid-1980s, around the same time when CIA's Aldrich Ames started his interaction with the KGB.
Ronald Montaperto – a senior DIA intelligence analyst who pled guilty in 2006 for giving classified information to China's MSS. Montaperto claimed that he was tricked and served only three months in jail due to letters of support from other pro-China intelligence analysts, pejoratively known as the "Red Team", who "harshly [criticize] anyone who raises questions about the threat posed by Beijing's communist regime." One of such supporters, Lonnie Henley, was initially reprimanded by the ODNI for his support of Montaperto but was later promoted to acting national intelligence officer for East Asia.
Waldo H. Dubberstein – a senior DIA intelligence officer for the Middle East and an associate of CIA arms smuggler Edwin P. Wilson who was indicted in 1983 for selling DIA secrets to Libya. The day after being charged, he was found dead in what was ruled a suicide.
Controversies
Alleged torture with drugs, gay porn, and loud music
In 2003, the Defense Secretary Donald Rumsfeld's "Working Group" on interrogations requested that DIA come up with prisoner interrogation techniques for the group's consideration. According to the 2008 US Senate Armed Services Committee report on the treatment of detainees in U.S. custody, DIA began drawing up the list of techniques with the help of its civilian employee, a former Guantanamo Interrogation Control Element (ICE) Chief David Becker. Becker claimed that the Working Group members were particularly interested in aggressive methods and that he "was encouraged to talk about techniques that
inflict pain."
It is unknown to what extent the agency's recommendations were used or for how long, but according to the same Senate report, the list drawn up by DIA included the use of "drugs such as sodium pentothal and Demerol," humiliation via female interrogators and sleep deprivation. Becker claimed that he recommended the use of drugs due to rumors that another intelligence agency, the name of which was redacted in the Senate report, had successfully used them in the past. According to the analysis of the Office of Defense Inspector General, DIA's cited justification for the use of drugs was to "[relax] detainee to cooperative state" and that mind-altering substances were not used.
Some of the more lurid revelations of DIA's alleged harsh interrogations came from FBI officers, who conducted their own screenings of detainees in Guantanamo along with other agencies. According to one account, the interrogators of what was then DIA's Defense Humint Service (referenced in FBI correspondence as DHS), forced subjects to watch gay porn, draped them with the Israeli flag, and interrogated them in rooms lit by strobe lights for 16–18 hours, all the while telling prisoners that they were from FBI.
The real FBI operatives were concerned that DIA's harsh methods and impersonation of FBI agents would complicate the FBI's ability to do its job properly, saying "The next time a real Agent tries to talk to that guy, you can imagine the result." A subsequent military inquiry countered FBI's allegations by saying that the prisoner treatment was degrading but not inhumane, without addressing the allegation of DIA staff regularly impersonating FBI officers—usually a felony offense.
Similar activities transpired at the hands of DIA operatives in Bagram, where as recently as 2010 the organization ran the so-called "Black Jail". According to a report published by The Atlantic, the jail was manned by DIA's DCHC staff, who were accused of beating and sexually humiliating high-value targets held at the site. The detention center outlived the black sites run by the Central Intelligence Agency, with DIA allegedly continuing to use "restricted" interrogation methods in the facility under a secret authorization. It is unclear what happened to the secret facility after the 2013 transfer of the base to Afghan authorities following several postponements.
DIA's harsh interrogation methods at times paled in comparison to those of some U.S. special operations forces. In 2004, interrogations by Joint Special Operations Command's high-value targets special operations task forces (including Task Force 6-26) were so heavy-handed and physical with the detainees that two DIA officials complained, as a result of which they were threatened and put under surveillance by abusive military interrogators. The two DIA officials managed to share their accounts of abuse with the agency leadership, prompting DIA Director Lowell Jacoby to write a memo on this topic to the Undersecretary of Defense for Intelligence.
Skinny Puppy controversy
In 2014, Canadian electronic music group Skinny Puppy sent the Defense Intelligence Agency a symbolic bill of $666,000, after finding out that the agency had used their music in Guantanamo during "enhanced interrogation" (deemed torture by some) sessions. Their music was originally heard at GTMO by a guard, who happened to be a fan of Skinny Puppy and could not understand how his favorite music was being used in such a manner: "[Skinny Puppy's] songs are characterized by ... lyrics that call out corporate wrongdoing. The songs I heard at GTMO were heavily distorted, almost to the point of inaudibility. Even so, I would never have imagined that Skinny Puppy's music would, or could, be used for enhanced interrogation". The officer conducting interrogation sessions allegedly stating that the Canadian group's songs—which are "characterized by relentless drumbeats, panicked, convulsive riffs, synth samples"—were very effective for "enhanced interrogation."
Attempts to expand domestic activities
Since mid-2000s, DIA has come under scrutiny for requesting new powers "to covertly approach and cultivate 'U.S. persons' and even recruit them as informants" without disclosing they are doing so on behalf of the U.S. government. George Peirce, DIA's general counsel, told The Washington Post that his agency is "not asking for the moon" and that DIA officers "only want to assess their [individual U.S. citizens'] suitability as a source, person to person", while protecting the ID and security of the agency operatives. The provision allowing DIA to covertly approach U.S. citizens was reportedly removed from the bill at the request of Senator Ron Wyden. It is unclear if the agency has received any additional powers since but it is known that until at least 2005 and possibly later, DIA's "personnel stationed in major U.S. cities [have been] ... monitoring the movements and activities—through high-tech equipment—of individuals and vehicles"; this occurred parallel to the NSA's warrantless surveillance that was of similarly dubious legality.
In 2008, with the consolidation of the new Defense Counterintelligence and Human Intelligence Center (DCHC), DIA secured an additional authority to conduct "offensive counterintelligence", which entails conducting clandestine operations, domestically and abroad, "to thwart what the opposition is trying to do to us and to learn more about what they're trying to get from us." While the agency remained vague about the exact meaning of offensive counterintelligence, experts opined that it "could include planting a mole in a foreign intelligence service, passing disinformation to mislead the other side, or even disrupting enemy information systems", suggesting strong overlap between CI and traditional HUMINT operations.
According to the agency, Americans spying for a foreign intelligence service would not be covered under this mechanism and that DIA would coordinate in such cases with the FBI which, unlike any DIA components at the time, is designated a law enforcement agency. The media showed particular interest in the domestic aspect of DIA's counterintelligence efforts due to the fact that agency's newly created DCHC had absorbed the former Counterintelligence Field Activity, which had become infamous for storing data on American peace activists in the controversial TALON database that was eventually shut down.
9/11 and Able Danger
Anthony Shaffer, a former DIA officer, has claimed that DIA was aware of and failed to adequately act against one of the organizers of the September 11 attacks prior to the event, in what became known as the Able Danger controversy. Shaffer's claims were rejected and later his security clearance was revoked, with the Pentagon denying any wrongdoing. Later Shaffer published his book Operation Dark Heart but, upon complaints from DIA and NSA that it included national security information, the Defense Department went as far as to buy and destroy the initial 10,000 copies of the book, causing the Streisand effect.
German Neo-Nazi murders
In 2011, the German government uncovered a far-right terrorist group named National Socialist Underground, which had been linked to a series of murders, including the murder of a police officer. A report by Stern claimed German BfV and DIA officers had witnessed the murder of a policewoman during their surveillance of the "Sauerland" group—an Islamist organization that planned attacks on U.S. military installations in Germany—but that neither of the agencies reported it, thus enabling subsequent violent acts by the same criminal entities. The magazine cited an unverified DIA report that confirmed the agency's officers were at the site of the incident. The authenticity of the alleged DIA observation protocol, on which Stern based its report, was swiftly denied by the BfV, while DIA refused to comment. An unnamed U.S. "insider expert" for intelligence matters told Der Spiegel he deemed it unlikely that DIA could be involved in that type of operation.
History
From World War II until the creation of DIA in 1961, the three Military Departments collected, produced and distributed their intelligence for individual use. This turned out to be duplicative, costly, and ineffective as each department provided their own, often conflicting estimates to the Secretary of Defense and other Federal agencies. While the Defense Reorganization Act of 1958 aimed to correct these deficiencies, the intelligence responsibilities remained unclear, the coordination was poor and the results fell short of national reliability and focus. As a result of this poor organization, President Dwight D. Eisenhower appointed the Joint Study Group in 1960 to find better ways for organizing the nation's military intelligence activities.
Acting on the recommendations of the Joint Study Group, Defense Secretary Robert S. McNamara advised the Joint Chiefs of Staff (JCS) of his decision to establish the DIA in February 1961. He ordered them to develop a plan that would integrate all the military intelligence of the DoD, a move that met strong resistance from the service intelligence units, whose commanders viewed DIA as undesirable encroachment on their turf. Despite this resistance, during the spring and summer of 1961, as Cold War tensions flared over the Berlin Wall, Air Force Lieutenant General Joseph Carroll took the lead in planning and organizing this new agency. The JCS published Directive 5105.21, "Defense Intelligence Agency" on August 1, and DIA began operations with a handful of employees in borrowed office space on October 1, 1961.
DIA originally reported to the Secretary through the JCS. The new agency's mission was the continuous task of collecting, processing, evaluating, analyzing, integrating, producing, and disseminating military intelligence for DoD and related national stakeholders. Other objectives included more efficiently allocating scarce intelligence resources, more effectively managing all DoD intelligence activities, and eliminating redundancies in facilities, organizations, and tasks.
DIA begins operation
Following DIA's establishment, the Services reluctantly transferred intelligence functions and resources to it on a time-phased basis to avoid rapidly degrading the overall effectiveness of defense intelligence. A year after its formation, in October 1962, the agency faced its first major intelligence test during the superpower Cuban Missile Crisis confrontation that developed after Soviet missiles were discovered at bases in Cuba by Air Force spy planes.
In late 1962, DIA established the Defense Intelligence School (now the National Intelligence University), and on January 1, 1963, it activated a new Production Center. Several Service elements were merged to form this production facility, which occupied the "A" and "B" Buildings at Arlington Hall Station, Virginia.
The agency also added an Automated Data Processing (ADP) Center on February 19, a Dissemination Center on March 31, and a Scientific and Technical Intelligence Directorate on April 30, 1963. DIA assumed the staff support functions of the J-2, Joint Staff, on July 1, 1963. Two years later, on July 1, 1965, DIA accepted responsibility for the Defense Attaché System—the last function the Services transferred to DIA.
During the 1960s, DIA analysts focused on China's detonation of an atomic bomb and the launching of its Cultural Revolution; increasing unrest among African and South Asian nations; fighting in Cyprus and Kashmir; and the missile gap between the U.S. and the Soviet Union. In the late 1960s, crises that tested intelligence responsiveness included: the Tet Offensive in Vietnam; the Six-Day War between Egypt and Israel; continuing troubles in Africa, particularly Nigeria; North Korea's seizure of the ; and the Warsaw Pact invasion of Czechoslovakia.
Years of transition
The early 1970s were transitional years as the agency shifted its focus from consolidating its functions to establishing itself as a credible producer of national-level intelligence. This proved difficult at first since sweeping manpower decrements between 1968 and 1975 had reduced agency manpower by 31 percent and precipitated mission reductions and a broad organizational restructuring. Challenges facing DIA at this time included the rise of Ostpolitik in Germany; the emergence of the Palestine Liberation Organization in the Middle East; and the U.S. incursion into Cambodia from South Vietnam.
The agency's reputation grew considerably by the mid-1970s, as decision makers increasingly recognized the value of its products. Agency analysts in 1972 concentrated on Lebanon, President Richard Nixon's visit to China, the 1973 Chilean coup d'état, the formation of Sri Lanka, and the prisoners of war being held in Southeast Asia. Subsequent challenges involved: détente; the development of arms control agreements; the Paris peace talks (Vietnam); the Yom Kippur War; and global energy concerns.
Intense Congressional review during 1975–76 created turbulence within the Intelligence Community. The Murphy and Rockefeller Commission investigations of charges of intelligence abuse ultimately led to an Executive Order that modified many Intelligence Community functions. At the same time, with U.S. involvement in Vietnam ending, defense intelligence faced a significant decline in resources. During this period, DIA conducted numerous studies on ways of improving its intelligence products. Despite these and other Community-wide efforts to improve intelligence support, the loss of resources during the 1970s limited the Community's ability to collect and produce timely intelligence and ultimately contributed to intelligence shortcomings in Iran, Afghanistan, and other strategic areas.
Special DIA task forces were set up to monitor crises such as the Soviet invasion of Afghanistan, the overthrow of Iranian monarchy, and the taking of American hostages from the U.S. embassy in Tehran in 1979. Also, of serious concern were the Vietnamese takeover in Phnom Penh, the China–Vietnam border war, the overthrow of Idi Amin in Uganda, the north–south Yemen dispute, troubles in Pakistan, border clashes between Libya and Egypt, the Sandinista takeover in Nicaragua, and the Soviet movement of combat troops to Cuba during the signing of the Strategic Arms Limitation Treaty II.
Following the promulgation in 1979 of Executive Order 12036, which restructured the Intelligence Community and better outlined DIA's national and departmental responsibilities, the agency was reorganized around five major directorates: production, operations, resources, external affairs, and J-2 support.
1980s
By the 1980s, DIA had transformed into a fully integrated national-level intelligence agency. Its 1981 flagship publication Soviet Military Power, the most comprehensive overview of Soviet military strength and capabilities at the time, was met with wide acclaim; SMP continued to be produced by DIA as a serialized publication roughly over the next decade. In 1983, in order to research the flow of technology to the Soviet Union, the Reagan Administration created Project Socrates within the agency. Over the following years Project Socrates's scope broadened to include monitoring of foreign advanced technology as a whole. Project Socrates ended in 1990 with Michael Sekora, the project's director, leaving in protest when the Bush Administration reduced funding.
In 1984, the Clandestine Services organization, designated STAR WATCHER, was created under DIA with the mission of conducting intelligence collection on perceived areas of conflict and against potential adversaries in developing countries. A critical objective was to create a Joint Services career path for case officers, since individual Services were inconsistent in their support of clandestine operations, and case officers were routinely sacrificed during reductions in force. Ultimately, the organization was created to balance CIA's espionage operations which primarily targeted Soviet KGB/GRU officers, but ignored and were dismissive of Third World targets in areas of potential military conflict.
Although there were previous attempts to establish such a DoD level espionage organization, there was no authorization document by which it could be established. This changed when Gregory Davis, a military intelligence officer, defined and established a clandestine services program under the U.S. Southern Command's "Plan Green". The program was then authorized by JCS Chairman John Vessey, and sanctioned by the Senate Select Committee on Intelligence ("SSCI"), with the sponsorship of Senator Jesse Helms (R-NC) and Senator Barry Goldwater (R-AZ). The Goldwater–Nichols DoD Reorganization Act was crafted partly to force military officers to serve in a Joint Services assignment in order to qualify for flag rank—ensuring the future of case officers from each Service. The clandestine organization within DIA grew and flourished, and was cited by the SSCI for its intelligence achievements. Personnel selection and training were rigorous, and the case officers were notable for their advanced educations, area knowledge, and multilingual capabilities. The program was partially gutted under President Bill Clinton as he foresaw no conflict which would justify its existence, but, it was resurrected under President George W. Bush.
Designated a combat support agency under the Goldwater–Nichols Act, DIA moved to increase cooperation with the Unified & Specified Commands and to begin developing a body of joint intelligence doctrine. Intelligence support to U.S. allies in the Middle East intensified as the Iran–Iraq War spilled into the Persian Gulf. DIA provided significant intelligence support to Operation Earnest Will while closely monitoring incidents such as the Iraqi rocket attack on the , the destruction of Iranian oil platforms, and Iranian attacks on Kuwaiti oil tankers. The "Toyota War" between Libya and Chad and the turmoil in Haiti added to DIA's heavy production workload, as did unrest in other parts of Latin America, Somalia, Ethiopia, Burma, Pakistan, and the Philippines.
Post–Cold War transformation
With the end of the Cold War, defense intelligence began a period of reevaluation following the fall of the Soviet system in many Eastern European countries, the reunification of Germany, and ongoing economic reforms in the region. In response to Iraq's invasion of Kuwait in August 1990, DIA set up an extensive, 24-hour, crisis management cell designed to tailor national-level intelligence support to the coalition forces assembled to expel Iraq from Kuwait. By the time Operation Desert Storm began, some 2,000 agency personnel were involved in the intelligence support effort. Most of them associated in some way with the national-level Joint Intelligence Center (JIC), which DIA established at The Pentagon to integrate the intelligence being produced throughout the Community. DIA sent more than 100 employees into the Kuwaiti Theater of Operations to provide intelligence support.
The Armed Forces Medical Intelligence Center (AFMIC), and the Missile and Space Intelligence Center (MSIC), associated with the Army for over 20 and 50 years respectively, became part of DIA in January 1992. This was part of the continuing effort to consolidate intelligence production and make it more efficient.
On September 11, 2001, seven DIA employees lost their lives along with 118 other victims at the Pentagon in a terrorist attack when American Airlines Flight 77 piloted by five Al-Qaeda hijackers plowed into the western side of the building, as part of the September 11 attacks. The death of seven employees at once was the largest combined loss in DIA's history. On September 11, 2009, DIA dedicated a memorial to the seven employees lost in the terrorist attacks on the Pentagon. The memorial is located in the garden at the Defense Intelligence Agency Analysis Center in Washington, D.C.
Since the September 11 attacks, DIA has been active in nuclear proliferation intelligence collection and analysis with particular interests in North Korea and Iran as well as counter-terrorism. DIA was also involved with the intelligence build-up to the invasion of Iraq in 2003 and was a subject in the Senate Report of Pre-war Intelligence on Iraq. After the invasion, DIA led the Iraq Survey Group to find the alleged Weapons of Mass Destruction. The agency has conflicted with the CIA in collection and analysis on the existence of weapons of mass destruction in Iraq and has often represented the Pentagon in the CIA–DoD intelligence rivalry due to DIA's own Clandestine HUMINT collection.
In 2012, DIA announced an expansion of clandestine collection efforts. The newly consolidated Defense Clandestine Service (DCS) would absorb the Defense HUMINT Service and expand DIA's overseas espionage apparatus to complement the work of corresponding elements at CIA. DCS would focus on military intelligence concerns—issues that the CIA has been unable to manage due to lack of personnel, expertise or time—and would initially deal with Islamist militia groups in Africa, weapons transfers between North Korea and Iran, and Chinese military modernization. The DCS works in conjunction with CIA's Directorate of Operations and the Joint Special Operations Command in overseas operations.
In October 2015, the Pentagon said that DIA appointed a British Royal Air Force officer as its first deputy director in charge of improving integration between U.S. intelligence units and spy agencies of other English-speaking countries in the Five Eyes alliance. This was the first time that a foreign national was appointed to a senior position at a U.S. intelligence agency.
Today, corporations carry out a large amount of DIA's workload. In fiscal year 2020 alone, such activity included work in DIA's Science & Technology Directorate, National Media Exploitation Center, and Missile & Space Intelligence Center. Corporations also worked on technology transfer analysis and assessments at DIA's Charlottesville branch, planned and analyzed DIA's workforce, carried out technical support, and conducted polygraph examinations and background investigations.
Memorial wall
A memorial wall at the DIA headquarters is dedicated to those agency employees who lost their lives in the line of their intelligence work and whose deaths are not classified. The wall was first dedicated on December 14, 1988, by Director Leonard Perroots. It "commemorates the profound individual sacrifices made on behalf of the United States by DIA members and acts as a reminder of the selflessness, dedication, and courage required to confront national challenges..."
DIA also maintains a memorial in the headquarters courtyard dedicated to personnel lost in the attacks of 9/11 on the Pentagon. Additionally, the agency maintains the Torch Bearers Wall at its Headquarters. The Torch Bearers award is the highest honor bestowed to former DIA employees and recognizes their exceptional contributions to the agency's mission.
In popular culture
The Brave is an American military action drama TV series that depicts the missions of an elite covert operations team of the Defense Intelligence Agency (DIA), similar to that of the DIA's Defense Clandestine Service.
Gemini Man is a 2019 American science fiction action thriller film directed by Ang Lee about a black ops sniper working for the DIA.
Adam Brody played DIA prisoner Benjamin "the Tank" Danz in the 2005 film, Mr. & Mrs. Smith.
Denzel Washington portrays former DIA operative turned vigilante Robert McCall in the film version of The Equalizer (2014) and its two sequels.
Seal
The flaming torch and its gold color represent knowledge, i.e., intelligence, and the dark background represents the unknown—"the area of the truth" still sought by the worldwide mission of the agency. The two red atomic ellipses symbolize the scientific and technical aspects of intelligence today and of the future. The 13 stars and the wreath are adopted from the Department of Defense seal and mean glory and peace, respectively, which the DoD secures as part of its work.
Badge
See also
Central Intelligence Agency
National Security Agency
Director of National Intelligence
GRU
Coast Guard Intelligence Center
Defense Attaché System
JFCC ISR (US Strategic Command)
Marine Corps Intelligence Activity
Missile and Space Intelligence Center
National Intelligence University
Office of Naval Intelligence
Strategic Support Branch
G-2 (intelligence)
UK Defence Intelligence
Defence Intelligence Organisation (Australia)
References
External links
Government agencies established in 1961
Military intelligence agencies
United States Department of Defense agencies
United States intelligence agencies
Intelligence analysis agencies |
Sir William George Toop Goodman KBE MICE MIEE MIEAust (14 March 1872 – 4 February 1961), was an engineer and administrator who supervised the installation of New Zealand's first electric tramway and went on to oversee the foundation and growth of the Municipal Tramways Trust in Adelaide, South Australia.
Early life
William Goodman was born in Kent, either in St Peter's or Ramsgate, a son of William Henry Goodman and his wife Emma Ann Goodman, née Limeburner, and educated at St George's School in Ramsgate. He later studied at King's College London and perhaps Finsbury Technical College. He was articled to Squire & Newton of London, then joined Maudslay & Field. In 1891 he joined the firm variously reported as Poole & Wight or Poole & White and worked on the Blackpool electric tramways, the Liverpool electric railway, the City & South London electric railway, and the City & South London Railway. He has also been reported as working for Simpson and Co. of London, and for his father, who may have been a consulting engineer or a carpenter.
Early engineering career
In 1894 Goodman may have visited America and Germany to gain further technical knowledge and experience. In October 1894 he was in Hobart, Tasmania as a representative of the Brush Electrical Engineering Company setting up that company's exhibit at the International Exhibition, then installing an electric lighting plant for the Mount Lyell Mine reducing works, and advising on the feasibility of installing a hydro-electric generator on the Zeehan Falls for a company floated by Samuel McLean.
In 1897 he joined the tramway construction branch of the Department of Public Works, New South Wales, and also served as an officer in the Sixth (Volunteer) Infantry Regiment. He next joined the Sydney engineering company Noyes Brothers for whom in May 1900 he travelled to New Zealand to install electric urban tramways to link with the Roslyn and Dunedin cable tramway systems, which had been designed and installed from 1881 by George Smith Duncan. He left Noyes Brothers in 1902 to take up an appointment as electrical engineer to the city of Dunedin, and was involved in the Waipori hydroelectric scheme, the Christchurch refuse destructor, tramways for Petone and Hutt, and Auckland city lighting.
Municipal Tramways Trust
In 1907 Goodman take up the position of electrical engineer with Adelaide's Municipal Tramways Trust.
Adelaide had an extensive network of horse-drawn trams, all privately owned, but Adelaide, usually in the vanguard of social reform, had fallen badly behind the other colonies in the modernisation of its public transport. After a referendum on 8 February 1902 which decisively opted for a private enterprise, as against a Municipal or Government, takeover and electrification of the lines, a Tramways Purchase Act was passed. It enabled businessman Francis Hugh Snow to buy out these operators and to convert to electric traction, giving him a time limit of three years. After Snow failed to raise the required capital an Electric Traction Act of 1904 authorised the Government to make offers to these seven companies for the purchase of their leases and assets, which if rejected would be put in the hands of an arbitrator.
Eventually a takeover price of £280,000 was agreed upon and the Municipal Tramways Trust Act was passed in 1906. The Trust consisted of eight members: two nominated by the Governor, and two each from the Adelaide City Council, the Suburban Corporations, and the District Councils (those further out, which included Burnside and Mitcham). The Trust appointed the State's Engineer in Chief, Alexander Bain Moncrieff CMG (c. 1845–1928) as chairman, and advertised for a tramways engineer. Goodman was their unanimous choice; he started on the job in May 1907; one of his first appointments was his assistant John Bowman (1867–1951), a graduate of Sydney University who had worked with him in Sydney and in Dunedin. Within twelve months Goodman had called for contracts to the value of £457,000.
The following year he was further appointed chief engineer and general manager. Goodman retired from the MTT in 1950 at the age of 78.
Other highlights of Goodman's professional life included the following.
Royal Commission into public transport Auckland, New Zealand
In 1928 he and Alfred Edward Edwards? of Sydney were appointed to a Royal Commission chaired by J. S. Barton of Whanganui, into the tram service in Auckland where the introduction of competing private bus services had resulted in crippling financial losses to the tram service and financial failure of the bus companies. Having buses servicing outlying areas created expectations that the services would continue, leading to compulsory takeover of uneconomic routes by district councils, which were then saddled with recurring debt.
The terms of enquiry were:
The adequacy, efficiency and suitability of the existing transport system maintained by the Auckland City Council and other existing transport services, as regards administration, equipment, working and financial provisions.
The working and effect in the district of the provisions of the Motor Omnibus Traffic Act, 1920, and its regulations.
The working and effect in the district of other statutes and regulations affecting vehicular transport.
The suitability for the district of motor omnibus transport, either in conjunction with or as an adjunct to tramway transport.
The most suitable form of transport for localities within and localities beyond the tram termini; whether services for such localities should be feeder services or through services or a combination of both; whether and to what extent such services should be conducted by local bodies or any other public management or by private enterprise; and whether and to what extent such services should be under the control of local bodies or any other public control.
The desirability of establishing a transport board for the district or any part of it, and if so, with what constitution, powers of control, powers of undertaking transport services and means of obtaining funds for its purposes, and whether such a board, if established, should take over all or any existing transport services, and if so upon what terms.
The Commission's report, handed to Parliament in late July 1928 made the following recommendations
That the Omnibus Act is justifiable to curb abuses which may result from uncontrolled competition, and to protect publicly owned services from unfair competition.
That the licensing of transport services (as is the case with licensing of drivers and vehicles) should be subject to annual renewal subject to conditions having been met.
That a surcharge of 2d. provided by section 10 of the Act for protection of municipal tramways was fair.
That the tram affords the most suitable form of transport in the city and closely settled suburban areas.
That the pneumatic-tyred petrol-driven motor-omnibus is the best form of transport beyond the reach of tramways.
That buses should not be limited to acting as a feeder service to a tram terminus, as this requires passengers to disembark and re-embark, and also complicates extraction of fares, but where possible should provide a through service.
That where a public utility is of a nature that it should be wholly or substantially a monopoly it should be publicly and not privately owned and operated, but in fringe areas the owning and controlling authority should, under proper conditions, permit and license private services.
Committee of Enquiry into the Hume reservoir
In May 1929 the three States with a vital interest in the Hume Dam, New South Wales, South Australia, and Victoria, impatient with progress of its construction, called for an enquiry. Commonwealth Minister for Works William Gibson appointed three commissioners: Goodman, Edgar Ritchie and EH Graves.
Its terms of reference were:
Whether the costs in regard to earthwork, concrete work, etc. are reasonable
The reasons why the estimates of cost, particularly in regard to road and rail deviations, so largely exceed those previously furnished
The reasons for the additional costs not having been anticipated when these estimates were being prepared;
Whether the work in connection with the acquisition of land and compensation for land affected by the works has been satisfactorily done;
The probable cost of completing the works with particular relation to the latest estimate thereof; and
Whether any and what changes in the present programme should be made in the interests of efficiency or proper economy.
The recommendations and outcome of this enquiry do not appear to have been made public.
Railway Investigation Committee (South Australia)
On 27 May 1930, at the onset of the Great Depression in Australia and with a serious drought gripping South Australia, the Hill Government appointed Goodman to head a committee to investigate the control and administration of the South Australian Railways and the causes of the heavy, and increasing, losses incurred. The other members of the committee were Charles Miscamble (former Railways Commissioner of Tasmania), John W. Wainwright (Assistant Auditor-General), and Archibald McInnes (secretary of the Boilermakers' Society). The inquiry was instigated only two weeks after the return to the United States of Railways Commissioner William Webb, who had been eight years in the job. Webb had become unpopular with the government for a number of reasons. Although South Australia was beginning to feel the effects of the depression evident in all states, much of the loss of revenue in the state was blamed on the railways. Most of the witnesses at the hearings were loyal to Webb, but the committee concluded that despite Webb's legacy being a greatly upgraded railway system, his ideas were too ambitious for the times; many of Webb's reforms had been expensive and extravagant, and had damaged the state's economy. Chief among their recommendations was that management of the railways should be run as a business on behalf of the taxpayers, removed from political influence, and be controlled by a board of six members selected on a non-party basis, with only the director having railway experience.
Other activities
Goodman joined The Institution for Electrical Engineers in 1899 and served on the South Australian Centre Committee from 1937 to 1946.
He served as chairman of the South Australian Housing Trust 1937–1944.
He was a member of the Council of the University of Adelaide 1913–1954.
He was appointed to the Motor Omnibus Board in March 1927.
His hobbies included flying, deep-sea diving and music.
He had interests in a number of private companies.
Family
He married Florence Letitia Attreed ( – 1956) on 7 January 1893. While in Adelaide the family lived at "Lea Lodge", Strangways Terrace, North Adelaide 1909–1916; LeFevre Terrace, North Adelaide 1917; Brougham Place, North Adelaide 1928–1952; and 58 Palmer Place, North Adelaide 1932–1949 (sic). Their children included:
Cyril William Goodman (30 December 1893 – 1978), an electrical engineer, married Ruth Ethel Muriel Butler (20 January 1897 – c. September 1976) on 28 April 1917. She was a daughter of Sir Richard Butler.
Raymond George Goodman (c. September 1896 – ) champion rifle shooter Adelaide University 1919, served as Captain in World War I, moved to Victoria 1923.
Eldest daughter Doris Florence Louise "Dolly" Goodman ( –1986) married Sydney Chester Thomas (1895–1968) on 15 November 1922.
Second daughter Gwendoline Letitia "Gwen" Goodman (1905–1998), married Andrew Tennant (c. 1899–1974) of "The Gap" and "Princess Royal" stations, Burra, on 11 October 1928. Andrew was a grandson of Andrew Tennant MP. Both were interred at the North Road cemetery.
Third daughter Joan Goodman (18 October 1907 – ) was engaged to Arthur Rymill (1907–1989) in 1932 but married Hurtle Cummins Morphett MC (1906–1992), son of George Hurtle Cummins Morphett (1877–1916), a descendant of Sir John Morphett, on 16 March 1937.
Youngest daughter Zella Emmeline "Zellie" Goodman (1912–2010), married (William) Kenneth Craig (1915–1996) of "Arrawatta", Deniliquin on 7 June 1941.
Death
Following a three year hospitalisation, Goodman died at College Park on 4 February 1961, aged 88. He was buried at North Road Cemetery, Nailsworth.
Recognition
Goodman was knighted in the 1932 New Year Honours "for public services to the State of South Australia".
He was awarded the Peter Nicol Russell Memorial Medal by the Institution of Engineers Australia in 1945.
A historic MTT building on Hackney Road (now part of the Adelaide Botanic Garden) was named the Goodman Building after him.
A former tram bridge in Holland Street, Thebarton was named the Sir William Goodman Bridge when reopened as part of a cycleway in September 2014.
Notes
References
Sources
Radcliffe, John C., 'Goodman, Sir William George Toop (1872–1961)', in Bede Nairn and Geoffrey Serle (eds), Australian Dictionary of Biography, vol. 9, Melbourne University Press, Melbourne, 1983, pp. 48–49. Also available at http://www.adb.online.anu.edu.au/biogs/A090047b.htm.
'Goodman, William George Toop', Trove, National Library of Australia, 2009, http://nla.gov.au/nla.party-1475625. Details
MCCARTHY, G.J.
Created: 20 October 1993, Last modified: 4 February 2010
Cite this: http://www.eoas.info/biogs/P001252b.htm
Encyclopedia of Australian Science 2015
Australian railway mechanical engineers
Australian electrical engineers
Public transport in South Australia
1872 births
1961 deaths
20th-century Australian engineers
19th-century Australian engineers |
Tanymecus lacaena is a species of broad-nosed weevil in the beetle family Curculionidae. It is found in North America.
References
Further reading
Entiminae
Articles created by Qbugbot
Beetles described in 1797 |
The Adoration of the Shepherds is a painting by the Italian Renaissance painter Lorenzo di Credi, dating to about 1510. It is displayed in the Uffizi Gallery of Florence.
History
The painting, commissioned by the nuns of Santa Chiara in Florence, is mentioned by the contemporary painter Mariotto Albertinelli and by the art biographer Giorgio Vasari, as well as in Florence's art guides from the late 17th century.
There are several preparatory studies, now at the Albertina of Vienna, the Cabinet des Dessins of Paris (the figure of St. Joseph) and the Gabinetto dei disegni e delle stampe at the Uffizi (for the lamb held by a shepherd).
Description
Under a ruined hut (a symbol of the declining pagan and Hebraic religions, is depicted the adoration of Jesus, who lies on a veil over a pile of straw; Jesus' features are similar to those used in some of Verrocchio's works. On the left, in a semicircle, are a shepherd with a lamb (symbol of Christ's sacrifice) looking on the left (inspired by Perugino), two praying shepherds inspired by the Portinari Triptych and perhaps Domenico Ghirlandaio, the Virgin, two standing and one kneeling angels with red clothes, and a standing St. Joseph, also inspired by Perugino. The Virgin and the angels are instead similar to features used by Leonardo da Vinci in works such as the Virgin of the Rocks.
External links
Page at the museum's website
1510 paintings
Paintings in the Uffizi
Lorenzo di Credi |
East Linden is a small community in the Canadian province of Nova Scotia, located in Cumberland County.
References
East Linden on Destination Nova Scotia
Communities in Cumberland County, Nova Scotia |
Jackman Flats Provincial Park is a provincial park in British Columbia, Canada, comprising approximately 615 ha. and located just southeast of Tête Jaune Cache in the Rocky Mountain Trench, near the Yellowhead Pass. The park features several hiking trails.
References
Robson Valley
Provincial parks of British Columbia
2000 establishments in British Columbia
Protected areas established in 2000 |
Sesto Pals, pen name of Simion (or Semion) Șestopali (born Шестопаль, also rendered as S(h)estopal, Sestopaly, or Sestopali; ca. 1912 – October 27, 2002), was a Russian-born Romanian and Israeli writer. Primarily a poet-philosopher, he also earned recognition as a graphic artist. He first became known in his teenage years, when, as a friend and associate of Gherasim Luca, he put out the review Alge. Its avant-garde aesthetics and its testing of censorship resulted in their prosecution. While Luca endured as a public intellectual and a founder of the Romanian surrealist cell, Pals became a recluse.
Forgotten by the general public, exposed to antisemitic and later communist persecution, he continued to write for himself and an intimate circle of friends. He had a successful career in civil and railway engineering, but political nonconformity resulted in his marginalization for part of the 1960s.
Moving to Haifa in 1970, Pals was rediscovered by later generations of Romanian and Israeli readers, known to them for the moderate surrealism of his poetry and prose, and, to a lesser degree, for his take on Hegelian philosophy. His editorial debut came well into his 80s, when Pals was already bedridden and contemplating death. This led to his rediscovery as a contributor to both Romanian and Israeli literature.
Biography
Early life
Simion "Senia" Shestopal, the scion of a Ukrainian Jewish family, was born in Odessa, officially on September 18, 1913, but more likely on September 5, 1912. According to literary historian Ovid Crohmălniceanu, his familiarity with Jewish mythology and the Hebrew language can be read as a clue that he was enlisted in a cheder. He lived in Odessa with his parents and his brother Fima until 1920, when they were chased out of the country by the revolutionary war.
His father obtained protection status from the Italian diplomatic mission, before moving with his family to Romania and legally changing his name to Emanoil Șestopali. Simion's mother, Berta née Berman, later arranged for her own relatives to settle in the new country. They lived in Galați, where Simion and Fima began their schooling, until 1923, then moved to Bucharest. Simion enlisted at the Matei Basarab High School, where he was colleagues with poet Gherasim Luca. Sharing a school-desk, the two became close friends. They also associated with Aurel Baranga, who was in the same school, but slightly younger. Their circle also included female colleagues and admirers, among them Henriette Iacobsohn, future wife of the cartoonist Saul Steinberg, and Amelia Pavel, later an essayist and art historian. Pavel, who vacationed with Simion at Sovata in summer 1930, remembered him as a "nice and well-behaved youth".
Nevertheless, all three young men made a habit of deriding cultural conventions: Pals was almost expelled from school when he burst out laughing during a lecture on poet-laureate Vasile Alecsandri. In 1930, having kept up with the Western European and Romanian avant-garde, Luca founded the radical youth magazine Alge ("Algae"), with collaborations from Șestopali (the nominal "chief editor"), Baranga, and Jules Perahim; they were later joined by Paul Păun. Șestopali experimented with literary pseudonyms, sometimes signing his work for Alge as D. Amprent and then, for the first time ever, Sesto Pals. A quasi-anagram of his Romanian name-and-initial, it was sometimes corrected to Șesto Pals in later reference, but the poet always signed his work sans diacritic. The family name probably originated in a Russian moniker for "six fingers" or "six toes", and Șestopali bragged that he himself had inherited an extra toe.
Obscenity scandal
Underfunded, Alge only put out six or seven issues in this 1930 edition. By February 1932, Pals had established his own single-issue magazine, titled Muci ("Snot") and distributed free of charge at one of Perahim's art shows. Like Păun and the other Alge men, he was also co-opted by unu, the more established avant-garde sheet, but had a tense encounter with its editor, Sașa Pană. Nonetheless, unu hosted some of Pals' prose poems, including one which mockingly advertised Perahim's art as a "horrid crime" against the state. In addition to writing poetry, he was interested in hard science, taking his baccalaureate with honors in physics. He barely passed the overall examination, after having again slammed Alecsandri's work in his Romanian literature paper.
In 1933, Luca reissued Alge in a more licentious edition, and challenged the cultural establishment by sending a copy to Nicolae Iorga, the nationalist historian and political figure. A clampdown on their activities followed: all known contributors were caught in a police investigation, and Pals' home was searched for incriminating proof. Despite no longer being a contributor (and feeling alienated by Păun and Baranga's leftist militancy), Pals was implicated by his nominal editorial contribution. He was eventually arrested and sent to Văcărești prison, where his colleagues were also rounded up. Pals later recalled being subjected to a thorough interrogation by the examining magistrate, and sharing a cell with a known communist. Taking his instructions from Iorga, the coroner alleged that the Șestopalis were themselves communists, sent in from the Soviet Union to subvert Romanian society. The family was threatened with expulsion.
The writers' parents eventually obtained their release, with Emanoil pleading with his son that he amend his ways. The court ruled against the Alge group, and issued two-year suspended sentences against them. This tarnished their judicial record, leaving Pals exposed to persecution. Pals was traumatized by the whole experience, and no longer bothered with his college admission, although his grades qualified him for enlistment at the Bucharest Polytechnic.
In 1934, when he and his family were naturalized Romanian, Pals finally matriculated with the Polytechnic, where he majored in mining engineering and metallurgy. He kept out of literary life. When, in 1939, Luca returned from Paris a committed surrealist, Pals was invited to attend the sessions of his Bucharest surrealist circle. He did so on occasion, meeting with new recruits such as Dolfi Trost and Gellu Naum, but, as Pals biographer Michäel Finkenthal notes, "chain smoked [and] kept himself dead silent." Pals himself later asserted: "I never did 'fade' out of sight, I have always been out of sight."
Antisemitic persecution and communist oppression
Pals graduated in 1940, just as the National Renaissance Front dictatorship had barred Jews from employment in most fields, including technical. Pushed out of literary life, Pals discovered philosophy, and became an avid reader of Hegel. Finkenthal notes that his "rather obsessive preoccupation" was "to quantify qualitative values", a "strange mixture of Hegelianism and abstract arithmetic". Then, at the height of World War II, the Șestopalis came to be persecuted under tighter racial laws. Pals' brother Fima escaped to Palestine. Pals was singled out for compulsory labor, and sent to work as a "Jewish engineer" for the State Railways. Making occasional returns to Bucharest, he had an amorous affair with Lucia "Lucy" Metsch, a Paris-trained painter of Bukovina Jewish extraction. She had narrowly escaped the Einsatzgruppen, and was working at The Barașeum.
Pals sought full employment after the antifascist coup of 1944, and, in 1945, was dispatched to oversee the construction of railway tunnels in Cluj County. Later that year, he returned to Bucharest, joining the City Planning Institute as founder and president of its geotechnical engineering section. In 1946, engineer Șestopali parted with Lucy and married Valentina Berman. This created controversy: Valentina was Pals' first cousin and his junior by 15 years. She was also Holocaust survivor, having just returned from the concentration camp in Berezivka, Transnistria. Although he still refrained from an open affiliation, Pals continued to visit Luca and the surrealists, introducing his wife to them. His half-sister-in-law, Mura Vlad, was a published novelist and translator from Russian.
The marriage soon crumbled: Pals was an absentee husband, and Valentina found it hard to cope with the rigors of life in Communist Romania. Working as a typist, she met the poet Ion Caraion, becoming his admirer, muse, and lover. Pals accepted the informal separation, resuming his love affair with Lucy Metsch, who now worked as a scenic painter for Sahia Film. He was increasingly withdrawn and troubled, dedicating himself to writing down a whole corpus of literary and philosophical works that he would not publish.
During that decade, the Șestopalis came into conflict with the communist regime. In 1957, an investigation began into Caraion's samizdat poetry, which was highly critical of the regime, and which Valentina had helped circulate. At the risk of incriminating himself, Pals returned to his conjugal home and protected his estranged wife. In mid 1958, Valentina was arrested by the Securitate, then implicated in Caraion's trial for sedition. She dismissed the option to denounce Caraion in exchange for freedom, and was sentenced to 15 years of hard labor.
In 1962, Pals applied for an exit visa and emigration to Israel, a rebellious gesture which saw his demotion with reduced pay and his relocation to the remote town of Dej. Valentina, released from prison under a general amnesty, divorced him in 1963, and later married Caraion. Pals also married Lucy in 1965, and, starting 1967, retook his position at the Bucharest Planning Institute. He earned respect in the engineers' community, and had several professional awards to his name, while privately working on a set of essays which sought to reconcile Hegelianism with existentialism and phenomenology.
Emigration
By his own account, Pals lived a quiet and exceptionally fulfilling life down to 1970: caught up in his work during daytime, he turned to writing literature at night, and reconnected with his avant-garde friends. He still refrained from going public, although two of his close friends, former avant-garde writers Baranga and Geo Bogza, were well regarded by the regime and could arrange him a publishing deal. He was more preoccupied with discovering (as he put it) "the mystery of existence through one's own existence". That interval came to an end in 1970, when he and his wife were allowed to emigrate. They were seen to their plane by Bogza, the dissenting communist. Pals was forced by the authorities to leave his voluminous manuscripts behind in Romania; he split them into fascicles, which he hid in various places. Ion and Valentina Caraion, together with their daughter Marta, were themselves allowed to leave in 1981, moving to Lausanne. Caraion, who had agreed to collaborate with the Securitate in return for his freedom, was repeatedly blackmailed by his former supervisors.
Pals resumed his professional career in Haifa, where he oversaw the digging of utility tunnels. He traveled outside the country to meet Luca, who was living in Paris. However, his health declined abruptly, and he was forced to take retirement in 1982. He suffered from gastrointestinal cancer, and was treated at the Rabin Medical Center.
Working from his home, a small apartment in Bnei Brak, Pals focused entirely on philosophical essays, which he composed in French, and a new set of visual poetry pieces. He reluctantly agreed to have samples of these works published in Romanian diaspora magazines—including Caraion's Don Quijote and Alexandru Lungu's Argo. In 1985, the Honolulu exile Ștefan Baciu dedicated him a special issue of his MELE, a poetry newsletter. It included homage pieces by his old friends Păun and Bogza. Interviewed about his work by journalist Solo Har-Herescu in 1993, Pals was oblique: "I am not fit to answer, as my head is filled with those snake-like questions, poisoning my replies, eating them up as they [...] bite into their own tails, making it hard to know where tails begin and heads end." His only reason for writing was "an inner urging", as "so much better poems" already existed, which were still "of no use to the reading public".
Final years and death
Sesto Pals the poet was rediscovered in Romania only after the 1989 Revolution: in 1998, Nicolae Tzone published a book of his poetry with Editura Vinea, as Omul ciudat ("The Bizarre Man"). It was only at this time that Pals' former colleagues in the Bucharest Planning Institute discovered that he was the same as the avant-garde poet, as one of them confessed in a letter to the editors. Omul ciudat had a small circulation and, according to critic Răzvan Voncu, was only popular among the "connoisseurs of the avant-garde". The book earned Pals the Benjamin Fondane Award, granted by the Association of Romanian Writers in Israel. Pals' health condition was declining to such a degree that he had to be carried to that ceremony; by 1999, he was bedridden and tube-fed, but fully conscious and perfecting poems that were supposed to convey his final message to the world. He was still working on this on October 17, 2002, when he had to be taken to hospital.
Pals died in Tel Aviv, on October 27, 2002. Just days before this happened, the Romanian review Tribuna hosted three of his final poems. Pals' last work saw print a month later, in Ultima Oră, the Tel Aviv Romanian-Jewish newspaper. A revised edition of Omul ciudat came out at Editura Paideia, with illustrations by Mariana Macri, daughter of Pals' friend Ionathan X. Uranus.
Much of Pals' sizable fortune was bequeathed to the Rabin Medical Center, founding a research unit "for early detection and prevention of gastrointestinal cancer". Pals was survived by Lucy, who died in 2006, and by Valentina Caraion, both of whom participated in the effort to recover and edit his work. Although most of Pals' texts remained unpublished and under-researched, a follow-up to Omul ciudat, titled Întuneric și lumină ("Darkness and Light") was put out in Romania in 2007.
His 2013 centennial was celebrated in Romania under the auspices of the Museum of Romanian Literature and Gaudeamus Book Fair. Interest in Pals' work and personality was kept alive by the philosopher-physicist Michäel Finkenthal, who also collected some of the lesser known prose works into a 2014 anthology. A fictionalized portrayal of Pals as "the bizarre poet" is found in Virgil Duda's 2011 novel, Un cetățean al lumii ("A Citizen of the World").
Work
Various exegetes have reached the conclusion that Pals' Alge poetry is ahead of its time and context, one of the more notable contribution to the second-wave avant-garde in Romania. Paul Cernat describes a clash of visions between the "prophetic" ambitions of Alge and Pals' character, that of a "vulnerable introvert, terrorized by the precariousness of the human condition". According to Ion Pop, some of these poems stand out among the "purely awkward exercises" of youth, as "unhinged" expressionist pieces in succession to those of Adrian Maniu and Jules Laforgue. Other, tamer, pieces were directly inspired by the hermetic Ion Barbu and the mainstream modernist Tudor Arghezi. Several poems are singled out by Crohmălniceanu for being biblical-themed and distinctly apocalyptic, while yet others are "socially-inspired", "unanimistic" and "fraternal", addressed to "those people I meet on the tram".
By the mid-1950s, when he settled for a format of blank verse and haikus, Pals was prone to philosophical meditation, and explored much deeper into lyrical themes. As argued by Finkenthal, this change was prompted by his separation from Valentina: "From now on, the poet finds himself locked in a world where things happen, things change, where there is no longer room for any refuge into love or wisdom." According to Voncu, there was another cultural layer: like Gellu Naum and other late arrivals on the avant-garde scene, Pals was moving away from the sheer negativity of Alge, and attempting to construct instead a post-philosophical surrealism. Cernat sees Pals' surrealism as having "a familiar face", with classical-format quatrains like those of Tristan Tzara, H. Bonciu, and Jacques Prévert.
Some of Pals' poems, tentatively dated to 1958, seemingly allude to Valentina's arrest by the communists and the whole wave of political repression. Such dark and brooding works are held by both Finkenthal and Voncu as proof that Caraion and Pals influenced each other directly, despite their erotic rivalry. One fragment depicts silent struggles between the scheming fishermen and their catch, implying that fish still have a dying hope:
In 1960s prose poems which display influences from Franz Kafka or Urmuz, Pals amplified his sense of bafflement about the human condition. Nonetheless, Finkenthal writes, his very series of lyrical verse hints at "truths that are inaccessible to common mortals". He reconciled himself with the idea of time by denying its concreteness, but drew a line between general time and "the time of creation". The latter allowed for a future, and therefore provided room for "affirmation and oblivion". This meant that, "once he puts himself on the line, an artist will have to fade into his own affirmation." The moribund Pals sketched out a quaint prophecy:
References
References
Ovid Crohmălniceanu, Evreii în mișcarea de avangardă românească, Editura Hasefer, Bucharest, 2001.
Ion Pop, "Un 'om ciudat': Sesto Pals", in Steaua, Nr. 7-8/2009, pp. 41–43
Mariana Sipoș, " 'Rămâne-o lacrimă năucă' — de vorbă cu Valentina Caraion", in Jurnalul Literar, Nr. 7-10/1999, pp. 6–7
External links
Pals, Sesto, in The YIVO Encyclopedia of Jews in Eastern Europe
The Bucharest Surrealist Group (collective portrait), in Europeana database
1910s births
2002 deaths
20th-century Romanian poets
21st-century Romanian poets
20th-century Israeli poets
21st-century Israeli poets
Romanian male poets
Israeli male poets
Jewish Romanian writers
Jewish Ukrainian poets
Expressionist poets
Romanian surrealist writers
20th-century essayists
Romanian essayists
20th-century Romanian philosophers
Romanian science writers
Philosophers of science
Hegelian philosophers
Jewish existentialists
Romanian writers in French
Romanian magazine editors
Romanian magazine founders
Romanian illustrators
Israeli illustrators
Writers who illustrated their own writing
Politehnica University of Bucharest alumni
Romanian mining engineers
Geotechnical engineers
Romanian metallurgists
Train drivers
Odesa Jews
Emigrants from the Russian Empire to Romania
Jewish refugees
Soviet emigrants to Romania
Naturalised citizens of Romania
Obscenity controversies in literature
Romanian prisoners and detainees
Prisoners and detainees of Romania
Căile Ferate Române people
Censorship in Romania
Romanian people of World War II
Romanian emigrants to Israel
Deaths from cancer in Israel
Deaths from stomach cancer |
Roberto Emanuel Oliveira Alves (born 8 June 1997) is a Swiss professional footballer who plays as a midfielder for Radomiak Radom.
Early life
Alves was born in 1997 in Wetzikon, Switzerland, to Portuguese immigrants.
Club career
In 2019, Alves signed for Swiss second-tier side FC Winterthur, helping them earn promotion to the Swiss top flight.
In 2022, he signed for Polish side Radomiak Radom.
International career
Alves has represented Switzerland internationally at youth level and is eligible to represent Portugal internationally through his parents.
Style of play
Alves mainly operates as an attacking midfielder and is known for his ability to create goalscoring opportunities.
Personal life
Alves has regarded Portugal international Cristiano Ronaldo as one of football idols. He has a brother.
References
1997 births
Living people
People from Wetzikon
Men's association football midfielders
Swiss footballers
Switzerland men's youth international footballers
Grasshopper Club Zürich players
FC Wil players
FC Winterthur players
Radomiak Radom players
Swiss Challenge League players
Ekstraklasa players
Swiss expatriate men's footballers
Expatriate men's footballers in Poland
Swiss expatriate sportspeople in Poland
Swiss people of Portuguese descent |
Renaud Boyoud (born 7 May 1980) is a French former rugby union international who represented France in three Test matches. He played most of his club rugby for US Dax and Aviron Bayonnais.
Boyoud, a native of Grenoble, was a prop and made his debut for France in the 2008 tour of Australia. In the first Test in Sydney, Boyoud came on off the bench in the second half, replacing Lionel Faure. A week later in Brisbane he earned a starting berth and was cited for striking James Horwill, for which he received a three-week suspension. He also featured in the 2009 Six Nations Test against Scotland at Stade de France.
See also
List of France national rugby union players
References
External links
1980 births
Living people
French rugby union players
France international rugby union players
US Dax players
Aviron Bayonnais players
Rugby union props
Sportspeople from Grenoble
Rugby union players from Isère |
Ye'nze is the debut studio album recorded by Ugandan soul-jazz musician Sandra Nankoma. The album was produced by artist Kaz Kasozi and recorded at Little Room Studio in Kampala, Uganda and mastered in Paris, France, by David Felgeirolles.
The album was released on 22 February 2018 as a digital download in France where she had been in a three month residency (August – October, 2017) after she had won the music award Visa Pour La Creation by Institute Francaise France and on CD on 11 March 2018 at a press listening session held by Fezah App at Design Hub in Kampala.
Content
The album has a track listing of 10 songs,a poem interlude and an outro poem Paris Monster. The album presents themes about love, the daily struggles of survival, materialism, stigma against dark-skinned women, and poor political leadership in Uganda. All songs on the album were written by Sandra herself and most of the songs reflect to her life and the challenges she has gone through as a woman, and with a real darker skin. She titled the album Ye'nze, a Luganda phrase meaning It's me to reflect herself and her live on the album.
Singles
"Mercedes"
"Kaddugala"
"Baliba Baambuza"
Track listing
Credits and personnel
Sandra Nankoma – vocals, songwriter
Michael Avron– guitars
David Felgeirolles – mastering
Christophe Pittet bass
Felix Sabal-Lecco - drums
Kaz Kasozi - Multi-instrumentalist, Sound recording and reproduction
References
2018 debut albums
Sandra Nankoma albums |
The following articles contain lists of villages in Hinthada District, Burma (Myanmar):
List of villages in Hinthada Township
List of villages in Ingapu Township
List of villages in Kyangin Township
List of villages in Laymyethna Township
List of villages in Myanaung Township
List of villages in Zalun Township |
Sophie Pitt-Turnbull discovers America (2003) is a young adult novel by Dyan Sheldon. It follows the adventures of a narrow-minded, very conventional girl, Sophie, as she ventures to America to stay with her mother's old friend, Mrs Salamanca. Initially she hates life in America and living with the Salamancas. However, over time, she comes to love the place and people.
Sophie Pitt-Turnbull lives in Putney, England. Every year, she is desperate to go to France. But with the arrival of her brother Xar and her father writing another novel she cannot go, much to her disappointment, particularly as her best friend Jocelyn Scolfield is going out with her ex.
Her mother's old art school friend Mrs Salamanca asks if Sophie would like to swap places with her daughter Cherry who wants to go to Europe.
When Sophie arrives at JFK New York City airport she is surprised to find that Jake (Mrs Salamanca) arrives very late, is a Brooklyn resident and drives a run down van. When Sophie arrives with them at her new home she is shocked to find that she has to share a room with Cherry's sister. She sleeps on a mattress on the floor.
Sophie is most upset to find that her case is not there and has been lost by the airline. On Monday Jake goes to work Sophie is horrified to find herself looking after the two younger children. She drops them off at clue and spends the rest of the proceeding days doing Yoga in the living room.
Companion novel
The companion novel, I Conquer Britain, details the experiences of Cherokee Salamanca on her exchange trip to Putney. It was first published in 2006.
2003 American novels
American young adult novels
Novels set in New York City |
Pylons Project is an open-source organization that develops a set of web application technologies written in Python. Initially the project was a single web framework called Pylons, but after the merger with the repoze.bfg framework under the new name Pyramid, the Pylons Project now consists of multiple related web application technologies.
Pyramid
Pyramid is an open source web framework written in Python and is based on WSGI. It is a minimalistic web framework inspired by Zope, Pylons and Django.
Originally called "repoze.bfg", Pyramid gathered attention mostly in the Zope and Plone community as the Open Society Institute's KARL project migrated from Plone to BFG. In 2010 it was announced that the Pylons framework will move over to using BFG as a base in version 1.5. As a result of the inclusion of BFG into the Pylons project, BFG was renamed Pyramid.
Features
Pyramid is a minimalistic, platform-independent web framework. It is persistence agnostic and is integrated both with SQL databases via SQLAlchemy and with the Zope Object Database, as well as other NoSQL databases, such as CouchDB.
Pyramid allows developers to define routes using regular expressions that map to objects. Like its fellow framework Zope, Pyramid also allows hierarchical object traversal, where each part of a URL is an object containing other objects, in a way that is similar to folders in a filesystem.
Pylons Web Framework
Pylons Framework is an open-source Web application framework written in Python. It makes extensive use of the Web Server Gateway Interface standard to promote reusability and to separate functionality into distinct modules. It is strongly influenced by Ruby on Rails: two of its main components, Routes and WebHelpers, are Python reimplementations of Rails features.
Structure
Pylons is well known for having a near-complete stack of third-party tools, eschewing the "not-invented-here" phenomenon.
Installation, dependencies, and setup
The official installation method of Pylons is through EasyInstall via the Python Package Index (PyPI), and most of the additional tools are typically installed the same way. EasyInstall also handles package dependencies when relevant. Some distributions could also package Pylons and Paste, but it is likely that any distribution's packages would lag the official distribution. Pylons may also be installed by hand by renaming its .egg file to .zip and extracting the contents.
Paste is used for project setup, testing, and deployment. Using the common INI configuration format, Paste allows for multiple "profiles", so that developers can run development and deployment setups from the same codebase without revealing sensitive parts of Pylons, such as the interactive debugger, to production users.
URL dispatch
Currently the only widely used URL dispatcher for Pylons is Routes, a Python reimplementation of Ruby on Rails' URL dispatching, although any WSGI-compatible URL dispatcher can be used. While Routes is a separate library, it was developed for use in Pylons and its development remains closely in sync with Pylons.
HTML generation
Another piece of Rails adapted for Pylons is WebHelpers, which provides URL mapping based on the Routes configuration. WebHelpers also provides some utility functions for generating JavaScript code making use of the script.aculo.us and Prototype libraries.
FormEncode and FormBuild are used for HTML form validation and generation; there has been some use of Mako for form generation using Mako's inheritance model.
Templating
Myghty was the default Pylons templating language, but as of version 0.9.6 it has been replaced by Mako. Both templating languages are text-based (as opposed to XML-based), and support includes, inheritance and embedding arbitrary Python code.
Because of Pylons' loosely coupled layers, other templating languages can be used as well. Genshi, an XML-based templating language, can be used in lieu of either Mako or Myghty.
Database abstraction and object-relational mapping
Pylons has no default database library. Both SQLObject and SQLAlchemy are known to be used.
Merger with repoze.bfg and birth of Pyramid Web Framework
Pylons has developed into the Pylons Project, and the old code from Pylons 1.0 is now in maintenance-only mode. However, pursuant to the project's merger with repoze.bfg since November 2010, newer versions of Pylons are actually different from the original Pylons 1.0. Pylons developers initially planned to rewrite certain portions of the code, but they observed that the new code was approximating repoze.bfg, which led to the merger of Pylons and repoze.bfg. This led to repoze.bfg (a part of the Repoze Python-based web framework) to become rebranded and relaunched as the Pyramid web framework.
See also
Django (web framework)
FastAPI
Flask (web framework)
Web2py
TurboGears: a derivative project, built on top of Pylons
Tornado
Comparison of web frameworks
References
Further reading
External links
Cross-platform free software
Free software programmed in Python
Python (programming language) software
Python (programming language) web frameworks
fr:Pyramid (framework)
ru:Pyramid (программный каркас) |
W.W. Thorne Stadium, an American football and soccer venue, is the home stadium of the Aldine Independent School District's (Aldine ISD) five varsity high school football teams - the Aldine Mustangs, Davis Falcons, Eisenhower Eagles, MacArthur Generals and Nimitz Cougars of District 18-6A, as well as for each schools' varsity boys and girls soccer teams.
Thorne Stadium is located in north Houston, Texas, on Aldine-Bender Road just south of Beltway 8, a short distance from George Bush Intercontinental Airport and Greenspoint Mall. It is part of the Aldine ISD Athletic Complex, which includes Thorne Stadium, the M.O. Campbell Center for basketball and volleyball, Elliott Lansford Field for baseball, and the Aldine ISD Softball Complex for softball.
Thorne Stadium seats approximately 10,000 fans and has parking for 1,600 cars. The home stands are located on the west side, while the east side is the visitors’ side. The playing field is at ground level while each set of stands is built into an artificial earthen embankment. Fans enter the stadium through four gates situated at the top of each corner of the facility. Concessions and restrooms are located adjacent to the entrances.
Thorne Stadium's amenities include a FieldTurf artificial playing surface and a 36-foot by 19-foot Spectrum video scoreboard located in the north end of the stadium. There are also two air-conditioned dressing rooms, two training rooms, an officials’ dressing room and a conference room (all located in the adjoining M.O. Campbell Center arena in the south end of the stadium). Thorne Stadium's press box contains facilities for scoreboard/clock operation, TV/radio broadcasts, newspaper reporting, game filming and several coaches’ boxes.
In addition to hosting Aldine ISD varsity football and soccer games, Thorne Stadium has often been used by other southeast Texas schools as a neutral playoff site. The facility was also the home stadium for the Blue Chip Classic high school all-star football game.
The St. Louis BattleHawks of the XFL will use the stadium for its preseason training camp from January 4-22, 2020.
As of 2022, Thorne Stadium is currently undergoing a major renovation which will be expected to be completed by 2024.
History
Aldine ISD voters approved a $29 million bond package in 1973 that included funds for a number of new building projects, including construction of a new athletic complex, of which a football stadium would be one component.
Little or no action was taken on the project until 1977. On September 8, 1977, a small section of the home side (west) bleachers at the existing Aldine Athletic Stadium (located on the campus of Aldine High School) collapsed before a high school football game between the home Aldine Mustangs and the visiting Carver Panthers. Five Aldine High band members were injured when they fell through the resulting hole 20 feet to the pavement below. The stadium was closed for the rest of the football season pending an investigation. The four Aldine ISD varsity football teams at the time (Aldine, Carver, MacArthur and Eisenhower) had to play their remaining home games at Cy-Fair ISD's Bobcat Stadium, which was vacant because Cy-Fair had just opened a new football stadium a few weeks before.
In January 1978, Aldine ISD announced plans for a new $4.39 million, 10,000-seat stadium to replace Aldine Athletic Stadium in time for the start of 1979 high school football season. The stadium would be located on a 47-acre plot on Aldine-Bender Road, just to the east of Aldine-Westfield, near the district's central office and its original set of schools. The stadium's design would be similar to that of the then-recently opened Mercer Stadium in Fort Bend ISD.
Eventually, Aldine ISD would name its new stadium in honor of W.W. Thorne, who had been the district's superintendent of schools from 1958 to 1973. Thorne had guided Aldine ISD through a financial crisis that threatened to close the district in 1959 and oversaw its tremendous growth through the 1960s and early 1970s.
Thorne Stadium was slated to open September 7, 1979, with the Aldine Mustangs hosting the Conroe Tigers. However, workers had not finished installation of the stadium's artificial playing surface and the game was moved to Aldine Athletic Stadium. Eisenhower's season-opener against C.E. King on September 8 was also moved to Aldine Athletic Stadium. Instead, the visiting Houston Lee Generals defeated the home team MacArthur Generals 31-13 in the stadium's first game a week later, on September 14.
In 1996, Aldine ISD replaced Thorne Stadium's original field house in the facility's south end with the M.O. Campbell Center multipurpose arena. Football and soccer teams have since used the Campbell Center's dressing and conference rooms to prepare for games.
On August 30, 2008, KTRK-TV broadcast the Nimitz Cougars’ season-opening football game at Thorne Stadium against the visiting Alief Elsik Rams on its digital channel, 13.2. Two years later, on September 4, 2010, KTRK-TV broadcast the Aldine Mustangs’ game against the Deer Park Deer from Thorne Stadium, again on its 13.2 digital channel. The game was noteworthy in that the head coaches of both teams – Chris Massey of Deer Park and Lionell Crawford of Aldine – were former Aldine High School quarterbacks.
Thorne Stadium has been home for several successful football teams since its opening in 1979. The Aldine Mustangs won the 1990 Texas Class 5A Regular Division state title and ESPN (in conjunction with the National Prep Poll) named them its mythical national high school football champs that season as well. Aldine had also advanced to the Class 5A Finals in 1989. The MacArthur Generals reached the 1993 Class 5A Division II Finals while the Eisenhower Eagles made it to the 1999 Class 5A Division I championship game.
As of the end of the 2015 football season, Eisenhower has won or shared 11 district titles since Thorne Stadium's opening in 1979, Aldine nine, MacArthur four, while Nimitz and Davis have one apiece. Each team has also advanced to the playoffs numerous times as district runner-up (except Davis, which only began varsity play in 2014 and has one runner-up playoff berth and one shared district championship in two seasons).
In June 2022, Aldine ISD voted to replace Thorne Stadium with a new stadium on the site of the current stadium. The newly renovated stadium is set to open in 2024. While the renovations are ongoing, the varsity football teams in Aldine ISD will play their home games at George Stadium in Spring ISD. The newly renovated stadium, also to be named Thorne Stadium, will begin construction after the existing Thorne Stadium is demolished. It will feature two tiered stands, a community room, improved parking, a new larger scoreboard, along with other improvements. Also, the stadium's West Side and East Side lighting will change colors, depending on which home team is playing.
References
External links
Aldine ISD Athletic Department
Aldine High School
Aldine Mustangs Football
Davis High School
Eisenhower High School
MacArthur High School
Nimitz High School
High school football venues in Texas
Soccer venues in Houston
American football venues in Houston |
Joseph Chambers (born January 19, 1936) is a Classical Pentecostal and has authored six books, co-authored 2 books, has written over 185 booklets, and made over 18 videos on various Christian related subjects, including a video series with an exposé on Benny Hinn, Kenneth Hagin, and The False Anointing. He was married to Juanita H. Chambers and has three children and six grandchildren.
Formerly an ordained minister of the Church of God (Cleveland, Tennessee), Chambers served as a pastor in Tabor City, North Carolina between 1957–1958, Rockwell, North Carolina between 1958–1964 and Black Mountain, North Carolina between 1964–1968. Since 1968, he has been senior pastor of Paw Creek Ministries (formerly Paw Creek Church of God) in Charlotte, North Carolina.
Early life and childhood
Chambers was illiterate until age 16, at the time of his conversion to Christianity. Prior to this, his alcoholic father committed suicide.
Education
After receiving General Educational Development (GED), he studied through Montreat-Anderson College and was granted a non academic Doctorate of Divinity Degree<Wikipedia-Doctorate of Divinity> from [[Non-accredited Indiana Christian University]<Wikipedia>], and was granted a Doctorate of Sacred Literature from Bethany Theological Seminary.
Political history
He served on the National Republican Congressional Committee from 1982–1990, and has been on the Mecklenburg Republican Executive Committee since 1990 to this day.
Church history
In 1992, Chambers and his church withdrew from the Church of God over a conflict involving doctrinal issues about the Charismatic movement, a departure from the King James Bible and holiness. Subsequently, Paw Creek Ministries was sued by the Church of God in a long court battle, resulting in the seizure of their 20-acre, $3 million complex in northwest Charlotte. The church eventually moved to its own building a few miles away.
He is the Founder & President of Paw Creek Christian Academy (1974–Present), a Radio Host of One Hour Weekly Program, OPEN BIBLE DIALOGUE (1972–Present), the Founder & Chairman of Concerned Charlotteans (1983–Present), and the Co-Founder of Concerned Voice for Child Care (1985–Present).
He is the General Overseer of the Bible Holiness Ministerial Fellowship, which was organized in November 1998, and has ministers in the US and four foreign countries.
He is also member of The Pre Tribulation Research Centre, .
Website & Media Outreach
Chambers blogs on his website about current sociological issues. Through his email newsletters, he has stated opinions, based on well established Christian beliefs, that frequently differ from mainstream media figures such as Oprah Winfrey.
He reports spending over $100,000 a year on media outreach.
Published works
The challenge of the ministry, Pathway Press (Co-author)
Miracles, my Fathers delight, Pathway Press (Author)
Storming Toward Armageddon, New Leaf Press (Co-author)
A Palace for the Antichrist, New Leaf Press (Author)
Now! Rediscovering the Biblical Family
Now! Religious Mega Trends
Bread from the Master's Table
''Feast of Tabernacles'
References
1936 births
Montreat College alumni
Pentecostalism in North Carolina
Indiana Christian University alumni
American male writers
Living people
Religious leaders from North Carolina |
Loxioda fasciosa is a moth of the family Noctuidae. It is found in India.
References
Moths described in 1882
Calpinae
Moths of Asia |
Anglo Swiss or Anglo-Swiss describes people or things with joint English and Swiss connections. It may refer to:
Anglo Swiss Capital, investment company
Anglo-Swiss Condensed Milk Company, merged into Nestle |
Peter Turrini (born 26 September 1944 in Wolfsberg, Carinthia) is an Austrian playwright known for his socio-critical work and earlier folk-dramas.
Born in Carinthia, Turrini has been writing since 1971, when his play Rozznjogd premiered at the Volkstheater, Vienna. A versatile author, he has written plays, screenplays, poems, and essays. Rather than presenting an authentic picture of reality, in Turrini's understanding it is the function of the theatre to exaggerate and, by doing so, to raise the consciousness of the public.
He lives in Vienna and Retz, Lower Austria.
Selected dramas
Rozznjogd (1971)
Sauschlachten (1972)
Kindsmord (1973)
Josef und Maria (1980; revised version, 1999)
Die Bürger (1981)
Die Minderleister (1988)
Tod und Teufel (1990)
Alpenglühen (1993)
Die Schlacht um Wien (1995)
Tod und Teufel (1999) (opera, with music by Gerd Kühr)
Die Eröffnung (2000)
Ich liebe dieses Land (2001)
Der Riese vom Steinfeld (2002) (opera, with music by Friedrich Cerha)
Bei Einbruch der Dunkelheit (2005)
Jedem das Seine (co-authored with Silke Hassler) (2007)
Television
Die Alpensaga (1974–79) (mini-series)
Die Arbeitersaga (1988–90) (mini-series)
Further reading
Peter Turrini - Schriftsteller; Kämpfer, Künstler, Narr und Bürger, ed. Klaus Amann (Vienna: Residenz Verlag 2007) ().
1944 births
Living people
People from Wolfsberg
20th-century Austrian dramatists and playwrights
21st-century Austrian dramatists and playwrights
Austrian male dramatists and playwrights |
The Seminole in the American Civil War were found in both the Trans-Mississippi and Western Theaters. The Seminole Nation in the Trans-Mississippi Theater had split alliances. However, the majority of the tribe in the Western territories joined the Union Army under the leadership of Billy Bowlegs. Others, such as John Jumper, supported the Confederacy. The Florida Seminole participated in some skirmishing in central Florida. They were likely at the Battle of Olustee in February 1864.
Trans-Mississippi Theater
In 1884, The Philadelphia Inquirer stated that nearly all of the Seminoles "espoused the cause of the Union" and because all of the neighboring tribes (Choctaws, Chickasaws, Cherokees, and Creeks) "almost unanimously joined the Southern Confederacy, it was neither agreeable nor safe for the Seminoles to continue living in the Indian Territory." As the Seminole fled south, across the U.S.-Mexican border, "they were attacked by a Confederate regiment and their principal chieftain [Billy Bowlegs] killed." The remaining Seminoles crossed into Mexico and remained there until after the Civil War.
The Seminole Nation, those who didn't move to Mexico, was led by John Jumper. Jumper's Seminole name was "Hemha Micco." He was commissioned in the Confederacy as a major and then as an "honorary lieutenant colonel". He was in the battles of Round Mountain, Chusto-Talasah, Middle Boggy, and Second Cabin Creek.
Organization
The Seminole Nation organized into companies, battalions, and regiments.
First Seminole Battalion (Mounted Volunteers)
The First Seminole Battalion was organized on September 21, 1861.
Field & Staff: Major John Jumper
Companies: Company A (Captain George Cloud) and Company B (Captain Fushatchie Cochokna)
First Seminole Regiment (Mounted Volunteers)
The First Seminole Battalion re-organized as the 1st Seminole Regiment on July 1, 1864.
Field & Staff: Colonel John Jumper, Major George Cloud, Charles C. Dyer (A.Q.M.), D. R. Patterson (Adjutant), W. W. Burnes ( Assistant Surgeon), Hu McDonald (A.Q.M.)
Companies: Company A (Captain Thomas Cloud), Company B (Captain Fushatchie Cochokna), Company C (Captain James Factor), Company D (Captain Tustanucogee), Company E (Captain Sam Hill), and Company F (Captain Osuchee Harjo)
Western Theater
In Florida, two distinct companies were raised who had Seminole Indians as members of the Confederate Army. Andrew E. Hodges, a white man who lived on the coast near Cedar Key, raised a company of Indian sharp shooters starting in 1862. Hodges' Company not only had Seminole Indians but whites, Hispanics, blacks, and other tribal members in his unit. Seminoles may have played a sharp shooter role at the Battle of Olustee. By July 1864, Hodges had passed his company to Andrew M. McBride. McBride was elected captain and wrote Secretary of War James A. Seddon that the company was ready for service.
Hodges' Company
At the opening of the Civil War, Andrew E. Hodges was living near Cedar Key, Florida. In 1862, he was part of a home guard that navigated the waterways and coasts. Later that year he raised a company of sharp shooters.
McBride's Company
McBride had mustered 65 individuals on July 7, 1864, at Everglades, Florida. On the muster roll the following was declared, "We, the undersigned, respectfully volunteer and tender our services to the Confederate States of America, begging to be immediately admitted into their armies, having chosen A. McBride for our Captain."
Organization
Hodges' Company (organizational life: 1862-July 1864)
Company (Andrew E. Hodges)
McBride's Company (organizational life: July 1864 – 1865)
Company (Captain Andrew M. McBride)
Total: 65 men
Battles
Battle of Olustee
Aftermath
Trans-Mississippi Theater
Reconstruction was a particularly harsh for the Indian nations found west of the Mississippi.
Western Theater
After the War ended, the Seminole Indians became reclusive, and their history was obscured. Florida's Seminole Indians continue to live in and around the Everglades.
Both Andrew E. Hodges and Andrew M. McBride survived the War. They lived out the remainder of their lives in Florida.
See also
Florida in the American Civil War
Notes
References
External links
John Jumper.
Seminole
Native Americans in the American Civil War
Indian Territory in the American Civil War |
Faristenia kanazawai is a moth in the family Gelechiidae. It is found in Japan (Honshu).
The length of the forewings is 6.6–7 mm. The forewings are white, tinged with brownish grey except for the costa. There is a blackish dot on the costa at the base, as well as five blackish marks. A blackish dot is found on the subcostal near the base and there is a blackish elliptical mark above the tornus. The plical fold has a fuscous dot at two-seventh and there is an irregular fuscous streak from before the middle to the tornus, as well as a fuscous dot on the dorsal margin at one-seventh and a series of obscure fuscous dots on the costal margin and termen. The hindwings are pale brownish grey.
References
Faristenia
Moths described in 2000 |
District administration makes up the third level of government division in Nepal. The provision for a District Assembly, which acts as the legislature at the district-level, is mentioned in Part 17 of the Constitution of Nepal. The 77 districts of Nepal each have their own district assemblies which in turn elect their own District Coordination Committees, which serves as the executive at the district-level. In addition to this each district also has a District Administration Office which oversees the general administration of each district.
District Administration Office
The District Administration Office () is a general administration of government in each district of Nepal. The government of Nepal appoints a Chief District Officer in each district to function as a Chief Administration Officer.
The Local Administration Act, 2028 (1971) was implemented to conduct local administration in accordance with the decentralized administration system to effectively operate peace and order. Section 5 of the Local Administration Act was constituted to be a district administration office in every district to conduct general administration of the district. The DAO in each district of Nepal works under Ministry of Home Affairs. The main function of the DAO is to maintain peace, order and security in the district and provide assistance in development activities run by the federal government, provincial government, District Coordination Committee, urban municipality and rural municipality.
Chief District Officer
The Chief District Officer (, abbreviation: C.D.O.) is an administrative rank under Ministry of Home Affairs in Nepal who is appointed by the government as the senior-most executive magistrate and chief in-charge of general administration of a district . The main guideline to C.D.O. for his/her administration is the Local Administration Act, 1972. The C.D.O. is responsible for proper inspection of all the departments in a district such as health, education, security and all other government offices. In case of threatened public security conditions like riots, she/he can mobilize security forces and take other actions like imposing curfew order, fixing restricted area, arresting anyone according to law, hearing some cases as a quasi-judicial body. Distributing the Certificate of Nepalese Citizenship, processing and recommendation for passports, maintaining peace and security, law and order, acting as a representative of government, enjoying the authorities provided by more than 90 prevailing acts make a Chief District Officer powerful. The C.D.O. is the most powerful position in Nepalese administrative service. Likewise, Assistant Chief District Officers enjoys almost all the authorities as delegated by C.D.O. and other laws.
District Assembly
The District Assembly () is composed of chairpersons and vice-chairpersons of each rural municipality and mayors and deputy mayors of each municipality within a district. The District Assembly coordinates between all municipalities and rural municipalities within the district. It elects a nine-member District Coordination Committee including a chief and deputy chief and at least three women and one member from the Dalit or minority communities for a five-year term. Any member within the village or municipal assembly in local levels within the district are eligible to be elected to the District Coordination Committee and if elected their status as a local representative will lapse.
District Coordination Committee
The District Coordination Committee (, abbreviation: DCC) was formed on March 14, 2017, to replace the existing district development committee. Each of the 77 districts in Nepal have their own district coordination committees in.
The Head of a district development committee is elected by the district assembly. The government also appoints a Local Development Officer in each district development committee who heads the DCC in absence of an elected head or deputy head.
The DCC acts as an executive to the district Assembly. The DCC coordinates with the Provincial Assembly to establish coordination between the Provincial Assembly and rural municipalities and municipalities and to settle disputes, if any, of political nature. It also maintains coordination between the provincial and Federal government and among the local bodies in the district. It also monitors development within the district.
List of district coordination committees with their heads
See also
Gaunpalika
List of cities in Nepal
List of gaunpalikas of Nepal
Village development committee
District Development Committee
References
External links
Ministry of Federal Affairs and Local Development (Nepal)
Local government in Nepal
Districts of Nepal |
Brijraj Singh (21 February 1934 – 29 January 2022) was an Indian politician and a titular ruler as Maharao of Kotah from 1991 until his death.
He was the member of parliament from Jhalawar for three terms.
Biography
Singh was the only son of Sir Bhim Singh II, the last ruling Maharao of Kotah.
He married Maharani Maheshwari Devi Baisa, daughter of Maharawat Sir Ram Singhji II Bahadur of Pratapgarh, on 5 December 1956; they divorced on 11 September 1963 in Bombay.
His second marriage was on 21 May 1963, to Maharani Uttara Devi Sahiba, daughter of Maharaj Kumar Indrajitendra Narayan of Cooch Behar.
Singh served in various posts since 1958 including Chairman Board of Directors, Central Co-Operative Bank, Kotah, (1959–1961), MP (Lok Sabha) for Jhalawar 1962–1967, 1967–1970, and 1971–1977.
Singh was elected on the Indian National Congress ticket in 1962, and on the Bharatiya Jana Sangh ticket in 1967 and 1972.
He died from a heart attack in Kotah on 29 January 2022, at the age of 85.
Singh succeeded his father as the titular Maharao of Kotah in 1991, and was succeeded by his son Ijyaraj Singh upon his own death in 2022.
References
1934 births
2022 deaths
20th-century Indian royalty
People from Kota, Rajasthan
History of Kota, Rajasthan
Kotah, Brijraj Singh
Rajasthani people
India MPs 1962–1967 |
```c
/*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <stddef.h>
#include <sys/param.h>
#include "esp_log.h"
#include "esp_heap_caps.h"
#include "driver/gpio.h"
#include "sd_protocol_defs.h"
#include "driver/sdspi_host.h"
#include "sdspi_private.h"
#include "sdspi_crc.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "soc/soc_memory_layout.h"
/// Max number of transactions in flight (used in start_command_write_blocks)
#define SDSPI_TRANSACTION_COUNT 4
#define SDSPI_MOSI_IDLE_VAL 0xff //!< Data value which causes MOSI to stay high
#define GPIO_UNUSED 0xff //!< Flag indicating that CD/WP is unused
/// Size of the buffer returned by get_block_buf
#define SDSPI_BLOCK_BUF_SIZE (SDSPI_MAX_DATA_LEN + 4)
/// Maximum number of dummy bytes between the request and response (minimum is 1)
#define SDSPI_RESPONSE_MAX_DELAY 8
/**
* @brief Structure containing run time configuration for a single SD slot
*
* The slot info is referenced to by an sdspi_dev_handle_t (alias int). The handle may be the raw
* pointer to the slot info itself (force converted to, new API in IDFv4.2), or the index of the
* s_slot array (deprecated API). Returning the raw pointer to the caller instead of storing it
* locally can save some static memory.
*/
typedef struct {
spi_host_device_t host_id; //!< SPI host id.
spi_device_handle_t spi_handle; //!< SPI device handle, used for transactions
uint8_t gpio_cs; //!< CS GPIO, or GPIO_UNUSED
uint8_t gpio_cd; //!< Card detect GPIO, or GPIO_UNUSED
uint8_t gpio_wp; //!< Write protect GPIO, or GPIO_UNUSED
uint8_t gpio_int; //!< Write protect GPIO, or GPIO_UNUSED
/// GPIO write protect polarity.
/// 0 means "active low", i.e. card is protected when the GPIO is low;
/// 1 means "active high", i.e. card is protected when GPIO is high.
uint8_t gpio_wp_polarity : 1;
/// Set to 1 if the higher layer has asked the card to enable CRC checks
uint8_t data_crc_enabled : 1;
/// Intermediate buffer used when application buffer is not in DMA memory;
/// allocated on demand, SDSPI_BLOCK_BUF_SIZE bytes long. May be zero.
uint8_t* block_buf;
/// semaphore of gpio interrupt
SemaphoreHandle_t semphr_int;
} slot_info_t;
// Reserved for old API to be back-compatible
static slot_info_t *s_slots[SOC_SPI_PERIPH_NUM] = {};
static const char *TAG = "sdspi_host";
static const bool use_polling = true;
static const bool no_use_polling = true;
/// Functions to send out different kinds of commands
static esp_err_t start_command_read_blocks(slot_info_t *slot, sdspi_hw_cmd_t *cmd,
uint8_t *data, uint32_t rx_length, bool need_stop_command);
static esp_err_t start_command_write_blocks(slot_info_t *slot, sdspi_hw_cmd_t *cmd,
const uint8_t *data, uint32_t tx_length, bool multi_block, bool stop_trans);
static esp_err_t start_command_default(slot_info_t *slot, int flags, sdspi_hw_cmd_t *cmd);
static esp_err_t shift_cmd_response(sdspi_hw_cmd_t *cmd, int sent_bytes);
static esp_err_t poll_busy(slot_info_t *slot, int timeout_ms, bool polling);
/// A few helper functions
/// Map handle to pointer of slot information
static slot_info_t* get_slot_info(sdspi_dev_handle_t handle)
{
if ((uint32_t) handle < SOC_SPI_PERIPH_NUM) {
return s_slots[handle];
} else {
return (slot_info_t *) handle;
}
}
/// Store slot information (if possible) and return corresponding handle
static sdspi_dev_handle_t store_slot_info(slot_info_t *slot)
{
/*
* To be back-compatible, the first device of each bus will always be stored locally, and
* referenced to by the handle `host_id`, otherwise the new API return the raw pointer to the
* slot info as the handle, to save some static memory.
*/
if (s_slots[slot->host_id] == NULL) {
s_slots[slot->host_id] = slot;
return slot->host_id;
} else {
return (sdspi_dev_handle_t)slot;
}
}
/// Get the slot info for a specific handle, and remove the local reference (if exist).
static slot_info_t* remove_slot_info(sdspi_dev_handle_t handle)
{
if ((uint32_t) handle < SOC_SPI_PERIPH_NUM) {
slot_info_t* slot = s_slots[handle];
s_slots[handle] = NULL;
return slot;
} else {
return (slot_info_t *) handle;
}
}
/// Set CS high for given slot
static void cs_high(slot_info_t *slot)
{
if (slot->gpio_cs != GPIO_UNUSED) {
gpio_set_level(slot->gpio_cs, 1);
}
}
/// Set CS low for given slot
static void cs_low(slot_info_t *slot)
{
if (slot->gpio_cs != GPIO_UNUSED) {
gpio_set_level(slot->gpio_cs, 0);
}
}
/// Return true if WP pin is configured and is set as per its polarity
static bool card_write_protected(slot_info_t *slot)
{
if (slot->gpio_wp == GPIO_UNUSED) {
return false;
}
return gpio_get_level(slot->gpio_wp) == (slot->gpio_wp_polarity ? 1 : 0);
}
/// Return true if CD pin is configured and is high
static bool card_missing(slot_info_t *slot)
{
if (slot->gpio_cd == GPIO_UNUSED) {
return false;
}
return gpio_get_level(slot->gpio_cd) == 1;
}
/// Get pointer to a block of DMA memory, allocate if necessary.
/// This is used if the application provided buffer is not in DMA capable memory.
static esp_err_t get_block_buf(slot_info_t *slot, uint8_t **out_buf)
{
if (slot->block_buf == NULL) {
slot->block_buf = heap_caps_malloc(SDSPI_BLOCK_BUF_SIZE, MALLOC_CAP_DMA);
if (slot->block_buf == NULL) {
return ESP_ERR_NO_MEM;
}
}
*out_buf = slot->block_buf;
return ESP_OK;
}
/// Clock out one byte (CS has to be high) to make the card release MISO
/// (clocking one bit would work as well, but that triggers a bug in SPI DMA)
static void release_bus(slot_info_t *slot)
{
spi_transaction_t t = {
.flags = SPI_TRANS_USE_RXDATA | SPI_TRANS_USE_TXDATA,
.length = 8,
.tx_data = {0xff}
};
spi_device_polling_transmit(slot->spi_handle, &t);
// don't care if this failed
}
/// Clock out 80 cycles (10 bytes) before GO_IDLE command
static void go_idle_clockout(slot_info_t *slot)
{
//actually we need 10, declare 12 to meet requirement of RXDMA
uint8_t data[12];
memset(data, 0xff, sizeof(data));
spi_transaction_t t = {
.length = 10 * 8,
.tx_buffer = data,
.rx_buffer = data,
};
spi_device_polling_transmit(slot->spi_handle, &t);
// don't care if this failed
}
/**
* (Re)Configure SPI device. Used to change clock speed.
* @param slot Pointer to the slot to be configured
* @param clock_speed_hz clock speed, Hz
* @return ESP_OK on success
*/
static esp_err_t configure_spi_dev(slot_info_t *slot, int clock_speed_hz)
{
if (slot->spi_handle) {
// Reinitializing
spi_bus_remove_device(slot->spi_handle);
slot->spi_handle = NULL;
}
spi_device_interface_config_t devcfg = {
.clock_speed_hz = clock_speed_hz,
.mode = 0,
// For SD cards, CS must stay low during the whole read/write operation,
// rather than a single SPI transaction.
.spics_io_num = GPIO_NUM_NC,
.queue_size = SDSPI_TRANSACTION_COUNT,
};
return spi_bus_add_device(slot->host_id, &devcfg, &slot->spi_handle);
}
esp_err_t sdspi_host_init(void)
{
return ESP_OK;
}
static esp_err_t deinit_slot(slot_info_t *slot)
{
esp_err_t err = ESP_OK;
if (slot->spi_handle) {
spi_bus_remove_device(slot->spi_handle);
slot->spi_handle = NULL;
free(slot->block_buf);
slot->block_buf = NULL;
}
uint64_t pin_bit_mask = 0;
if (slot->gpio_cs != GPIO_UNUSED) {
pin_bit_mask |= BIT64(slot->gpio_cs);
}
if (slot->gpio_cd != GPIO_UNUSED) {
pin_bit_mask |= BIT64(slot->gpio_cd);
}
if (slot->gpio_wp != GPIO_UNUSED) {
pin_bit_mask |= BIT64(slot->gpio_wp);
}
if (slot->gpio_int != GPIO_UNUSED) {
pin_bit_mask |= BIT64(slot->gpio_int);
gpio_intr_disable(slot->gpio_int);
gpio_isr_handler_remove(slot->gpio_int);
}
gpio_config_t config = {
.pin_bit_mask = pin_bit_mask,
.mode = GPIO_MODE_INPUT,
.intr_type = GPIO_INTR_DISABLE,
};
if (pin_bit_mask != 0) {
gpio_config(&config);
}
if (slot->semphr_int) {
vSemaphoreDelete(slot->semphr_int);
slot->semphr_int = NULL;
}
free(slot);
return err;
}
esp_err_t sdspi_host_remove_device(sdspi_dev_handle_t handle)
{
//Get the slot info and remove the reference in the static memory (if used)
slot_info_t* slot = remove_slot_info(handle);
if (slot == NULL) {
return ESP_ERR_INVALID_ARG;
}
deinit_slot(slot);
return ESP_OK;
}
//only the slots locally stored can be deinit in this function.
esp_err_t sdspi_host_deinit(void)
{
for (size_t i = 0; i < sizeof(s_slots) / sizeof(s_slots[0]); ++i) {
slot_info_t* slot = remove_slot_info(i);
//slot isn't used, skip
if (slot == NULL) {
continue;
}
deinit_slot(slot);
}
return ESP_OK;
}
esp_err_t sdspi_host_set_card_clk(sdspi_dev_handle_t handle, uint32_t freq_khz)
{
slot_info_t *slot = get_slot_info(handle);
if (slot == NULL) {
return ESP_ERR_INVALID_ARG;
}
ESP_LOGD(TAG, "Setting card clock to %"PRIu32" kHz", freq_khz);
return configure_spi_dev(slot, freq_khz * 1000);
}
esp_err_t sdspi_host_get_real_freq(sdspi_dev_handle_t handle, int* real_freq_khz)
{
slot_info_t *slot = get_slot_info(handle);
if (slot == NULL) {
return ESP_ERR_INVALID_ARG;
}
return spi_device_get_actual_freq(slot->spi_handle, real_freq_khz);
}
static void gpio_intr(void* arg)
{
BaseType_t awoken = pdFALSE;
slot_info_t* slot = (slot_info_t*)arg;
xSemaphoreGiveFromISR(slot->semphr_int, &awoken);
gpio_intr_disable(slot->gpio_int);
if (awoken) {
portYIELD_FROM_ISR();
}
}
esp_err_t sdspi_host_init_device(const sdspi_device_config_t* slot_config, sdspi_dev_handle_t* out_handle)
{
ESP_LOGD(TAG, "%s: SPI%d cs=%d cd=%d wp=%d wp_polarity:%d",
__func__, slot_config->host_id + 1, slot_config->gpio_cs,
slot_config->gpio_cd, slot_config->gpio_wp, slot_config->gpio_wp_polarity);
slot_info_t* slot = (slot_info_t*)malloc(sizeof(slot_info_t));
if (slot == NULL) {
return ESP_ERR_NO_MEM;
}
*slot = (slot_info_t) {
.host_id = slot_config->host_id,
.gpio_cs = slot_config->gpio_cs,
};
// Attach the SD card to the SPI bus
esp_err_t ret = configure_spi_dev(slot, SDMMC_FREQ_PROBING * 1000);
if (ret != ESP_OK) {
ESP_LOGD(TAG, "spi_bus_add_device failed with rc=0x%x", ret);
goto cleanup;
}
// Configure CS pin
gpio_config_t io_conf = {
.intr_type = GPIO_INTR_DISABLE,
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = 1ULL << slot_config->gpio_cs,
};
if (slot_config->gpio_cs != SDSPI_SLOT_NO_CS) {
slot->gpio_cs = slot_config->gpio_cs;
} else {
slot->gpio_cs = GPIO_UNUSED;
}
if (slot->gpio_cs != GPIO_UNUSED) {
ret = gpio_config(&io_conf);
if (ret != ESP_OK) {
ESP_LOGD(TAG, "gpio_config (CS) failed with rc=0x%x", ret);
goto cleanup;
}
cs_high(slot);
}
// Configure CD and WP pins
io_conf = (gpio_config_t) {
.intr_type = GPIO_INTR_DISABLE,
.mode = GPIO_MODE_INPUT,
.pin_bit_mask = 0,
.pull_up_en = true
};
if (slot_config->gpio_cd != SDSPI_SLOT_NO_CD) {
io_conf.pin_bit_mask |= (1ULL << slot_config->gpio_cd);
slot->gpio_cd = slot_config->gpio_cd;
} else {
slot->gpio_cd = GPIO_UNUSED;
}
if (slot_config->gpio_wp != SDSPI_SLOT_NO_WP) {
io_conf.pin_bit_mask |= (1ULL << slot_config->gpio_wp);
slot->gpio_wp = slot_config->gpio_wp;
slot->gpio_wp_polarity = slot_config->gpio_wp_polarity;
if (slot->gpio_wp_polarity) {
io_conf.pull_down_en = true;
io_conf.pull_up_en = false;
}
} else {
slot->gpio_wp = GPIO_UNUSED;
}
if (io_conf.pin_bit_mask != 0) {
ret = gpio_config(&io_conf);
if (ret != ESP_OK) {
ESP_LOGD(TAG, "gpio_config (CD/WP) failed with rc=0x%x", ret);
goto cleanup;
}
}
if (slot_config->gpio_int != SDSPI_SLOT_NO_INT) {
slot->gpio_int = slot_config->gpio_int;
io_conf = (gpio_config_t) {
.intr_type = GPIO_INTR_LOW_LEVEL,
.mode = GPIO_MODE_INPUT,
.pull_up_en = true,
.pin_bit_mask = (1ULL << slot_config->gpio_int),
};
ret = gpio_config(&io_conf);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "gpio_config (interrupt) failed with rc=0x%x", ret);
goto cleanup;
}
slot->semphr_int = xSemaphoreCreateBinary();
if (slot->semphr_int == NULL) {
ret = ESP_ERR_NO_MEM;
goto cleanup;
}
gpio_intr_disable(slot->gpio_int);
// 1. the interrupt is better to be disabled before the ISR is registered
// 2. the semaphore MUST be initialized before the ISR is registered
// 3. the gpio_int member should be filled before the ISR is registered
ret = gpio_isr_handler_add(slot->gpio_int, &gpio_intr, slot);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "gpio_isr_handle_add failed with rc=0x%x", ret);
goto cleanup;
}
} else {
slot->gpio_int = GPIO_UNUSED;
}
//Initialization finished, store the store information if possible
//Then return corresponding handle
*out_handle = store_slot_info(slot);
return ESP_OK;
cleanup:
if (slot->semphr_int) {
vSemaphoreDelete(slot->semphr_int);
slot->semphr_int = NULL;
}
if (slot->spi_handle) {
spi_bus_remove_device(slot->spi_handle);
slot->spi_handle = NULL;
}
free(slot);
return ret;
}
esp_err_t sdspi_host_start_command(sdspi_dev_handle_t handle, sdspi_hw_cmd_t *cmd, void *data,
uint32_t data_size, int flags)
{
slot_info_t *slot = get_slot_info(handle);
if (slot == NULL) {
return ESP_ERR_INVALID_ARG;
}
if (card_missing(slot)) {
return ESP_ERR_NOT_FOUND;
}
// save some parts of cmd, as its contents will be overwritten
int cmd_index = cmd->cmd_index;
uint32_t cmd_arg;
memcpy(&cmd_arg, cmd->arguments, sizeof(cmd_arg));
cmd_arg = __builtin_bswap32(cmd_arg);
ESP_LOGV(TAG, "%s: slot=%i, CMD%d, arg=0x%08"PRIx32" flags=0x%x, data=%p, data_size=%"PRIu32" crc=0x%02x",
__func__, handle, cmd_index, cmd_arg, flags, data, data_size, cmd->crc7);
spi_device_acquire_bus(slot->spi_handle, portMAX_DELAY);
poll_busy(slot, 40, true);
// For CMD0, clock out 80 cycles to help the card enter idle state,
// *before* CS is asserted.
if (cmd_index == MMC_GO_IDLE_STATE) {
go_idle_clockout(slot);
}
// actual transaction
esp_err_t ret = ESP_OK;
cs_low(slot);
if (flags & SDSPI_CMD_FLAG_DATA) {
const bool multi_block = flags & SDSPI_CMD_FLAG_MULTI_BLK;
//send stop transmission token only when multi-block write and non-SDIO mode
const bool stop_transmission = multi_block && !(flags & SDSPI_CMD_FLAG_RSP_R5);
if (flags & SDSPI_CMD_FLAG_WRITE) {
ret = start_command_write_blocks(slot, cmd, data, data_size, multi_block, stop_transmission);
} else {
ret = start_command_read_blocks(slot, cmd, data, data_size, stop_transmission);
}
} else {
ret = start_command_default(slot, flags, cmd);
}
cs_high(slot);
release_bus(slot);
spi_device_release_bus(slot->spi_handle);
if (ret != ESP_OK) {
ESP_LOGD(TAG, "%s: cmd=%d error=0x%x", __func__, cmd_index, ret);
} else {
// Update internal state when some commands are sent successfully
if (cmd_index == SD_CRC_ON_OFF) {
slot->data_crc_enabled = (uint8_t) cmd_arg;
ESP_LOGD(TAG, "data CRC set=%d", slot->data_crc_enabled);
}
}
return ret;
}
static esp_err_t start_command_default(slot_info_t *slot, int flags, sdspi_hw_cmd_t *cmd)
{
size_t cmd_size = SDSPI_CMD_R1_SIZE;
if ((flags & SDSPI_CMD_FLAG_RSP_R1) ||
(flags & SDSPI_CMD_FLAG_NORSP) ||
(flags & SDSPI_CMD_FLAG_RSP_R1B)) {
cmd_size = SDSPI_CMD_R1_SIZE;
} else if (flags & SDSPI_CMD_FLAG_RSP_R2) {
cmd_size = SDSPI_CMD_R2_SIZE;
} else if (flags & SDSPI_CMD_FLAG_RSP_R3) {
cmd_size = SDSPI_CMD_R3_SIZE;
} else if (flags & SDSPI_CMD_FLAG_RSP_R4) {
cmd_size = SDSPI_CMD_R4_SIZE;
} else if (flags & SDSPI_CMD_FLAG_RSP_R5) {
cmd_size = SDSPI_CMD_R5_SIZE;
} else if (flags & SDSPI_CMD_FLAG_RSP_R7) {
cmd_size = SDSPI_CMD_R7_SIZE;
}
//add extra clocks to avoid polling
cmd_size += (SDSPI_NCR_MAX_SIZE - SDSPI_NCR_MIN_SIZE);
spi_transaction_t t = {
.flags = 0,
.length = cmd_size * 8,
.tx_buffer = cmd,
.rx_buffer = cmd,
};
esp_err_t ret = spi_device_polling_transmit(slot->spi_handle, &t);
if (cmd->cmd_index == MMC_STOP_TRANSMISSION) {
/* response is a stuff byte from previous transfer, ignore it */
cmd->r1 = 0xff;
}
if (ret != ESP_OK) {
ESP_LOGD(TAG, "%s: spi_device_polling_transmit returned 0x%x", __func__, ret);
return ret;
}
if (flags & SDSPI_CMD_FLAG_NORSP) {
/* no (correct) response expected from the card, so skip polling loop */
ESP_LOGV(TAG, "%s: ignoring response byte", __func__);
cmd->r1 = 0x00;
}
// we have sent and received bytes with enough length.
// now shift the response to match the offset of sdspi_hw_cmd_t
ret = shift_cmd_response(cmd, cmd_size);
if (ret != ESP_OK) {
return ESP_ERR_TIMEOUT;
}
if (flags & SDSPI_CMD_FLAG_RSP_R1B) {
ret = poll_busy(slot, cmd->timeout_ms, no_use_polling);
if (ret != ESP_OK) {
return ret;
}
}
return ESP_OK;
}
// Wait until MISO goes high
static esp_err_t poll_busy(slot_info_t *slot, int timeout_ms, bool polling)
{
uint8_t t_rx;
spi_transaction_t t = {
.tx_buffer = &t_rx,
.flags = SPI_TRANS_USE_RXDATA, //data stored in rx_data
.length = 8,
};
esp_err_t ret;
int64_t t_end = esp_timer_get_time() + timeout_ms * 1000;
int nonzero_count = 0;
do {
t_rx = SDSPI_MOSI_IDLE_VAL;
t.rx_data[0] = 0;
if (polling) {
ret = spi_device_polling_transmit(slot->spi_handle, &t);
} else {
ret = spi_device_transmit(slot->spi_handle, &t);
}
if (ret != ESP_OK) {
return ret;
}
if (t.rx_data[0] != 0) {
if (++nonzero_count == 2) {
return ESP_OK;
}
}
} while (esp_timer_get_time() < t_end);
ESP_LOGD(TAG, "%s: timeout", __func__);
return ESP_ERR_TIMEOUT;
}
// Wait for data token, reading 8 bytes at a time.
// If the token is found, write all subsequent bytes to extra_ptr,
// and store the number of bytes written to extra_size.
static esp_err_t poll_data_token(slot_info_t *slot, uint8_t *extra_ptr, size_t *extra_size, int timeout_ms)
{
uint8_t t_rx[8];
spi_transaction_t t = {
.tx_buffer = &t_rx,
.rx_buffer = &t_rx,
.length = sizeof(t_rx) * 8,
};
esp_err_t ret;
int64_t t_end = esp_timer_get_time() + timeout_ms * 1000;
do {
memset(t_rx, SDSPI_MOSI_IDLE_VAL, sizeof(t_rx));
ret = spi_device_polling_transmit(slot->spi_handle, &t);
if (ret != ESP_OK) {
return ret;
}
bool found = false;
for (size_t byte_idx = 0; byte_idx < sizeof(t_rx); byte_idx++) {
uint8_t rd_data = t_rx[byte_idx];
if (rd_data == TOKEN_BLOCK_START) {
found = true;
memcpy(extra_ptr, t_rx + byte_idx + 1, sizeof(t_rx) - byte_idx - 1);
*extra_size = sizeof(t_rx) - byte_idx - 1;
break;
}
if (rd_data != 0xff && rd_data != 0) {
ESP_LOGD(TAG, "%s: received 0x%02x while waiting for data",
__func__, rd_data);
return ESP_ERR_INVALID_RESPONSE;
}
}
if (found) {
return ESP_OK;
}
} while (esp_timer_get_time() < t_end);
ESP_LOGD(TAG, "%s: timeout", __func__);
return ESP_ERR_TIMEOUT;
}
// the r1 respond could appear 1-8 clocks after the command token is sent
// this function search for r1 in the buffer after 1 clocks to max 8 clocks
// then shift the data after R1, to match the definition of sdspi_hw_cmd_t.
static esp_err_t shift_cmd_response(sdspi_hw_cmd_t* cmd, int sent_bytes)
{
uint8_t* pr1 = &cmd->r1;
int ncr_cnt = 1;
while (true) {
if ((*pr1 & SD_SPI_R1_NO_RESPONSE) == 0) {
break;
}
pr1++;
if (++ncr_cnt > 8) {
return ESP_ERR_NOT_FOUND;
}
}
int copy_bytes = sent_bytes - SDSPI_CMD_SIZE - ncr_cnt;
if (copy_bytes > 0) {
memcpy(&cmd->r1, pr1, copy_bytes);
}
return ESP_OK;
}
/**
* Receiving one or more blocks of data happens as follows:
* 1. send command + receive r1 response (SDSPI_CMD_R1_SIZE bytes total)
* 2. keep receiving bytes until TOKEN_BLOCK_START is encountered (this may
* take a while, depending on card's read speed)
* 3. receive up to SDSPI_MAX_DATA_LEN = 512 bytes of actual data
* 4. receive 2 bytes of CRC
* 5. for multi block transfers, go to step 2
*
* These steps can be done separately, but that leads to a less than optimal
* performance on large transfers because of delays between each step.
* For example, if steps 3 and 4 are separate SPI transactions queued one after
* another, there will be ~16 microseconds of dead time between end of step 3
* and the beginning of step 4. A delay between two blocking SPI transactions
* in step 2 is even higher (~60 microseconds).
*
* To improve read performance the following sequence is adopted:
* 1. Do the first transfer: command + r1 response + 8 extra bytes.
* Set pre_scan_data_ptr to point to the 8 extra bytes, and set
* pre_scan_data_size to 8.
* 2. Search pre_scan_data_size bytes for TOKEN_BLOCK_START.
* If found, the rest of the bytes contain part of the actual data.
* Store pointer to and size of that extra data as extra_data_{ptr,size}.
* If not found, fall back to polling for TOKEN_BLOCK_START, 8 bytes at a
* time (in poll_data_token function). Deal with extra data in the same way,
* by setting extra_data_{ptr,size}.
* 3. Receive the remaining 512 - extra_data_size bytes, plus 4 extra bytes
* (i.e. 516 - extra_data_size). Of the 4 extra bytes, first two will capture
* the CRC value, and the other two will capture 0xff 0xfe sequence
* indicating the start of the next block. Actual scanning is done by
* setting pre_scan_data_ptr to point to these last 2 bytes, and setting
* pre_scan_data_size = 2, then going to step 2 to receive the next block.
* When the final block is being received, the number of extra bytes is 2
* (only for CRC), because we don't need to wait for start token of the
* next block, and some cards are getting confused by these two extra bytes.
*
* With this approach the delay between blocks of a multi-block transfer is
* ~95 microseconds, out of which 35 microseconds are spend doing the CRC check.
* Further speedup is possible by pipelining transfers and CRC checks, at an
* expense of one extra temporary buffer.
*/
static esp_err_t start_command_read_blocks(slot_info_t *slot, sdspi_hw_cmd_t *cmd,
uint8_t *data, uint32_t rx_length, bool need_stop_command)
{
spi_transaction_t t_command = {
.length = (SDSPI_CMD_R1_SIZE + SDSPI_RESPONSE_MAX_DELAY) * 8,
.tx_buffer = cmd,
.rx_buffer = cmd,
};
esp_err_t ret = spi_device_polling_transmit(slot->spi_handle, &t_command);
if (ret != ESP_OK) {
return ret;
}
uint8_t* cmd_u8 = (uint8_t*) cmd;
size_t pre_scan_data_size = SDSPI_RESPONSE_MAX_DELAY;
uint8_t* pre_scan_data_ptr = cmd_u8 + SDSPI_CMD_R1_SIZE;
/* R1 response is delayed by 1-8 bytes from the request.
* This loop searches for the response and writes it to cmd->r1.
*/
while ((cmd->r1 & SD_SPI_R1_NO_RESPONSE) != 0 && pre_scan_data_size > 0) {
cmd->r1 = *pre_scan_data_ptr;
++pre_scan_data_ptr;
--pre_scan_data_size;
}
if (cmd->r1 & SD_SPI_R1_NO_RESPONSE) {
ESP_LOGD(TAG, "no response token found");
return ESP_ERR_TIMEOUT;
}
while (rx_length > 0) {
size_t extra_data_size = 0;
const uint8_t* extra_data_ptr = NULL;
bool need_poll = true;
for (size_t i = 0; i < pre_scan_data_size; ++i) {
if (pre_scan_data_ptr[i] == TOKEN_BLOCK_START) {
extra_data_size = pre_scan_data_size - i - 1;
extra_data_ptr = pre_scan_data_ptr + i + 1;
need_poll = false;
break;
}
}
if (need_poll) {
// Wait for data to be ready
ret = poll_data_token(slot, cmd_u8 + SDSPI_CMD_R1_SIZE, &extra_data_size, cmd->timeout_ms);
if (ret != ESP_OK) {
return ret;
}
if (extra_data_size) {
extra_data_ptr = cmd_u8 + SDSPI_CMD_R1_SIZE;
}
}
// Arrange RX buffer
size_t will_receive = MIN(rx_length, SDSPI_MAX_DATA_LEN) - extra_data_size;
uint8_t* rx_data;
ret = get_block_buf(slot, &rx_data);
if (ret != ESP_OK) {
return ret;
}
// receive actual data
const size_t receive_extra_bytes = (rx_length > SDSPI_MAX_DATA_LEN) ? 4 : 2;
memset(rx_data, 0xff, will_receive + receive_extra_bytes);
spi_transaction_t t_data = {
.length = (will_receive + receive_extra_bytes) * 8,
.rx_buffer = rx_data,
.tx_buffer = rx_data
};
ret = spi_device_transmit(slot->spi_handle, &t_data);
if (ret != ESP_OK) {
return ret;
}
// CRC bytes need to be received even if CRC is not enabled
uint16_t crc = UINT16_MAX;
memcpy(&crc, rx_data + will_receive, sizeof(crc));
// Bytes to scan for the start token
pre_scan_data_size = receive_extra_bytes - sizeof(crc);
pre_scan_data_ptr = rx_data + will_receive + sizeof(crc);
// Copy data to the destination buffer
memcpy(data + extra_data_size, rx_data, will_receive);
if (extra_data_size) {
memcpy(data, extra_data_ptr, extra_data_size);
}
// compute CRC of the received data
uint16_t crc_of_data = 0;
if (slot->data_crc_enabled) {
crc_of_data = sdspi_crc16(data, will_receive + extra_data_size);
if (crc_of_data != crc) {
ESP_LOGE(TAG, "data CRC failed, got=0x%04x expected=0x%04x", crc_of_data, crc);
ESP_LOG_BUFFER_HEX(TAG, data, 16);
return ESP_ERR_INVALID_CRC;
}
}
data += will_receive + extra_data_size;
rx_length -= will_receive + extra_data_size;
extra_data_size = 0;
extra_data_ptr = NULL;
}
if (need_stop_command) {
// To end multi block transfer, send stop command and wait for the
// card to process it
sdspi_hw_cmd_t stop_cmd;
make_hw_cmd(MMC_STOP_TRANSMISSION, 0, cmd->timeout_ms, &stop_cmd);
ret = start_command_default(slot, SDSPI_CMD_FLAG_RSP_R1B, &stop_cmd);
if (ret != ESP_OK) {
return ret;
}
if (stop_cmd.r1 != 0) {
ESP_LOGD(TAG, "%s: STOP_TRANSMISSION response 0x%02x", __func__, stop_cmd.r1);
}
ret = poll_busy(slot, cmd->timeout_ms, use_polling);
if (ret != ESP_OK) {
return ret;
}
}
return ESP_OK;
}
/* For CMD53, we can send in byte mode, or block mode
* The data start token is different, and cannot be determined by the length
* That's why we need ``multi_block``.
* It's also different that stop transmission token is not needed in the SDIO mode.
*/
static esp_err_t start_command_write_blocks(slot_info_t *slot, sdspi_hw_cmd_t *cmd,
const uint8_t *data, uint32_t tx_length, bool multi_block, bool stop_trans)
{
if (card_write_protected(slot)) {
ESP_LOGW(TAG, "%s: card write protected", __func__);
return ESP_ERR_INVALID_STATE;
}
// Send the minimum length that is sure to get the complete response
// SD cards always return R1 (1bytes), SDIO returns R5 (2 bytes)
const int send_bytes = SDSPI_CMD_R5_SIZE + SDSPI_NCR_MAX_SIZE - SDSPI_NCR_MIN_SIZE;
spi_transaction_t t_command = {
.length = send_bytes * 8,
.tx_buffer = cmd,
.rx_buffer = cmd,
};
esp_err_t ret = spi_device_polling_transmit(slot->spi_handle, &t_command);
if (ret != ESP_OK) {
return ret;
}
// check if command response valid
ret = shift_cmd_response(cmd, send_bytes);
if (ret != ESP_OK) {
ESP_LOGD(TAG, "%s: check_cmd_response returned 0x%x", __func__, ret);
return ret;
}
uint8_t start_token = multi_block ?
TOKEN_BLOCK_START_WRITE_MULTI : TOKEN_BLOCK_START;
while (tx_length > 0) {
// Write block start token
spi_transaction_t t_start_token = {
.length = sizeof(start_token) * 8,
.tx_buffer = &start_token
};
ret = spi_device_polling_transmit(slot->spi_handle, &t_start_token);
if (ret != ESP_OK) {
return ret;
}
// Prepare data to be sent
size_t will_send = MIN(tx_length, SDSPI_MAX_DATA_LEN);
const uint8_t* tx_data = data;
if (!esp_ptr_in_dram(tx_data)) {
// If the pointer can't be used with DMA, copy data into a new buffer
uint8_t* tmp;
ret = get_block_buf(slot, &tmp);
if (ret != ESP_OK) {
return ret;
}
memcpy(tmp, tx_data, will_send);
tx_data = tmp;
}
// Write data
spi_transaction_t t_data = {
.length = will_send * 8,
.tx_buffer = tx_data,
};
ret = spi_device_transmit(slot->spi_handle, &t_data);
if (ret != ESP_OK) {
return ret;
}
// Write CRC and get the response in one transaction
uint16_t crc = sdspi_crc16(data, will_send);
const int size_crc_response = sizeof(crc) + 1;
spi_transaction_t t_crc_rsp = {
.length = size_crc_response * 8,
.flags = SPI_TRANS_USE_TXDATA | SPI_TRANS_USE_RXDATA,
};
memset(t_crc_rsp.tx_data, 0xff, 4);
memcpy(t_crc_rsp.tx_data, &crc, sizeof(crc));
ret = spi_device_polling_transmit(slot->spi_handle, &t_crc_rsp);
if (ret != ESP_OK) {
return ret;
}
uint8_t data_rsp = t_crc_rsp.rx_data[2];
if (!SD_SPI_DATA_RSP_VALID(data_rsp)) {
return ESP_ERR_INVALID_RESPONSE;
}
switch (SD_SPI_DATA_RSP(data_rsp)) {
case SD_SPI_DATA_ACCEPTED:
break;
case SD_SPI_DATA_CRC_ERROR:
return ESP_ERR_INVALID_CRC;
case SD_SPI_DATA_WR_ERROR:
return ESP_FAIL;
default:
return ESP_ERR_INVALID_RESPONSE;
}
// Wait for the card to finish writing data
ret = poll_busy(slot, cmd->timeout_ms, no_use_polling);
if (ret != ESP_OK) {
return ret;
}
tx_length -= will_send;
data += will_send;
}
if (stop_trans) {
uint8_t stop_token[2] = {
TOKEN_BLOCK_STOP_WRITE_MULTI,
SDSPI_MOSI_IDLE_VAL
};
spi_transaction_t t_stop_token = {
.length = sizeof(stop_token) * 8,
.tx_buffer = &stop_token,
};
ret = spi_device_polling_transmit(slot->spi_handle, &t_stop_token);
if (ret != ESP_OK) {
return ret;
}
ret = poll_busy(slot, cmd->timeout_ms, use_polling);
if (ret != ESP_OK) {
return ret;
}
}
return ESP_OK;
}
esp_err_t sdspi_host_io_int_enable(sdspi_dev_handle_t handle)
{
//the pin and its interrupt is already initialized, nothing to do here.
return ESP_OK;
}
//the interrupt will give the semaphore and then disable itself
esp_err_t sdspi_host_io_int_wait(sdspi_dev_handle_t handle, TickType_t timeout_ticks)
{
slot_info_t* slot = get_slot_info(handle);
//skip the interrupt and semaphore if the gpio is already low.
if (gpio_get_level(slot->gpio_int) == 0) {
return ESP_OK;
}
//clear the semaphore before wait
xSemaphoreTake(slot->semphr_int, 0);
//enable the interrupt and wait for the semaphore
gpio_intr_enable(slot->gpio_int);
BaseType_t ret = xSemaphoreTake(slot->semphr_int, timeout_ticks);
if (ret == pdFALSE) {
gpio_intr_disable(slot->gpio_int);
return ESP_ERR_TIMEOUT;
}
return ESP_OK;
}
esp_err_t sdspi_host_get_dma_info(int slot, esp_dma_mem_info_t *dma_mem_info)
{
(void)slot;
dma_mem_info->extra_heap_caps = MALLOC_CAP_DMA;
dma_mem_info->dma_alignment_bytes = 4;
return ESP_OK;
}
``` |
The Library of America (LOA) is a nonprofit publisher of classic American literature. Founded in 1979 with seed money from the National Endowment for the Humanities and the Ford Foundation, the LOA has published over 300 volumes by authors ranging from Nathaniel Hawthorne to Saul Bellow, Frederick Douglass to Ursula K. Le Guin, including selected writing of several U.S. presidents. Anthologies and works containing historical documents, criticism, and journalism are also published. Library of America volumes seek to print authoritative versions of works; include extensive notes, chronologies, and other back matter; and are known for their distinctive physical appearance.
Overview and history
The Bibliothèque de la Pléiade ("La Pléiade") series published in France provided the model for the LOA, which was long a dream of critic and author Edmund Wilson. During the 1960s and 1970s there was a long saga of rival literary outfits attempting to assemble and finding funding for much the same thing.
The founding of the Library of America took place in 1979, with the creation of an entity known as Literary Classics of the United States, Inc. (This remains the entity under which LOA notes, chronologies, and other auxiliary materials are copyrighted. And officially, employees work for Literary Classics of the United States, Inc.)
Publishers that were associated in some way with the creation included Lawrence Hughes, Helen Honig Meyer, and Roger W. Straus Jr. The initial board of advisers included Robert Penn Warren, C. Vann Woodward, R. W. B. Lewis, Robert Coles, Irving Howe, and Eudora Welty.
Funding at the start came from two sources, the National Endowment for the Humanities and the Ford Foundation, in the total amount of $1.8 million.
The initial president of the new entity was the American academic Daniel Aaron, who had been a friend of Wilson's since the 1950s. The executive director was Cheryl Hurley, who had worked at the Modern Language Association. Other founding officers included the literary critic Richard Poirier, as vice president, and the publisher Jason Epstein, as treasurer. Epstein, and later Aaron and Poirier, had all been involved in the long series of proposals and discussions that led up to the creation of the Library of America. Another founder was the textual scholar G. Thomas Tanselle; he too had been involved in the discussions prior to creation, and after that he chaired the committee that was the arbiter of LOA textual policy.
Aaron remained in his position until 1985, and was responsible for navigating the shoals between the orthodoxies of literary criticism and a wider view of what the Library of America could publish. He was followed as president by executive director Hurley. In 2017, she retired as president and was replaced by Max Rudin, who was already the entity's publisher.
Hanna M. "Gila" Bercovitch served as founding editor, senior editor, and then editor-in-chief until her death in 1997. Upon her passing, Henry Louis Gates said that "It is hard to find anyone who has been more central to institutionalizing the canon of American literature." She was followed as editor-in-chief by the poet and critic Geoffrey O'Brien. He retired in 2017, and was followed in 2018 by John Kulka, who was given the title of editorial director.
The first volumes were published in 1982, ten years after Wilson's death. They were priced moderately. The launch was accompanied by considerable amounts of publicity. Public response was in terms of sales positive from the beginning; by 1986, the non-profit was breaking even, although it accepted special grants for specific projects, such as one from the Bradley Foundation to enable the two-volume The Debate on the Constitution set. The response to the series continued to grow over time; between 1993 and 1996, the publisher's frontlist sales doubled. By 1996, the Library of America was getting two-thirds of its sales via subscription programs and one-third through bookstores. While for a long time the series only published the works of authors who had passed on, this changed in the late 1990s when Eudora Welty was published, soon to be followed by Philip Roth. Similarly, the rule that authors had to be American-born was later relaxed when Vladimir Nabokov was added to the list. While a nonprofit entity, the Library has not been immune to commercial considerations, often going further into genre works such as detective fiction and science fiction than some of its founders would have imagined.
Besides the works of many individual writers, the series includes anthologies such as (in a different format from the above illustration) Writing Los Angeles. The Library of America introduced coverage of American journalism with the 1995 two-volume set Reporting World War II, which not only garnered positive reviews, but soon became one of the publisher's five best-selling offerings to that point, the others being volumes about Abraham Lincoln, Ulysses S. Grant, William Tecumseh Sherman, and Walt Whitman. That those others all concerned the Civil War era was did not go unnoticed; one of the publisher's most ambitious later efforts, a multi-volume collection of first-person narratives, revolved around the same topic, as did such volumes as a collection of letters that Grant wrote to his wife Julia.
The publisher aims to keep classics and notable historical and genre works in print permanently to preserve America's literary and cultural heritage. Previously, often only the best-known works of an author remained in print, as exemplified by Stephen Crane, whose novels and short stories were but whose poetry and journalism were not. As LOA chief executive Cheryl Hurley stated in 2001, "We're not only a publisher, we're a cultural institution." Although the LOA sells more than a quarter-million volumes annually, with the original seed money having run out, the publisher depends on individual contributions to help meet the costs of preparing, marketing, manufacturing, and maintaining its books. In one large form of donation, as of 2001 a $50,000 contribution could sponsor a particular book being kept in print. Some books published as additions to the series are not kept in print in perpetuity.
Research and scholarship
Library of America volumes are prepared and edited by recognized scholars on the subject. Notes on the text are normally included and the source texts identified; these notes have been called "fascinating in themselves". This is part of the extensive back matter typically included with each volume, behind which large amounts of research and scholarship are conducted.
Efforts are made to correct errors and omissions in previous editions and create a definitive version of the material. For instance, under of the guidance of Bercovitch, the LOA text of Richard Wright's Native Son restored a number of passages that had been previously cut to make the work more palatable to the Book-of-the-Month Club. The LOA also commissioned a new translation of Alexis de Tocqueville's Democracy in America by Arthur Goldhammer for their edition of the text. Library of America volumes of letters tend to be representative rather than exhaustive in terms of inclusion criteria.
Unlike some other series such as the Norton Critical Editions, Library of America volumes provide no introductory essays or critical examinations of the work involved. This is per Wilson's original design. At times this omission can lead to frustration based on the inability to know the basis upon which material for a volume was selected.
Each volume also includes a chronology of the author's career or significant incidents in the case of the anthology volumes. Indeed, Library of America volumes are noted for their chronologies; the New York Times has called them "predictably superb". The author and journalist Gloria Emerson's review of the Reporting World War II volumes notes that they include "an excellent chronology of the war". The poet and literary critic Stephen Yenser, in reviewing of volume about the work of the poet Elizabeth Bishop, noted that the chronology was "so packed with pertinent details it amounts to a mini-biography". The notes and chronologies are often put together by LOA staff members and in some cases have informed the perspective of the guest editors working on the volume in question. LOA staff have also sometimes helped scholars working on related projects.
Critical reception
The Library of America has received considerable praise for its endeavors. After the initial series were published, the critic Charles Champlin wrote that "The volumes in the series are in fact marvels of scholarship, unobtrusively displayed, and a prime effort has been to work from the text that reflects the author's final word." The poet and literary critic Stephen Yenser has called the Library of America "invaluable"; that same term has been used to describe Library of America by the Cox News Service, by the Los Angeles Times, and by a book prize committee.
Newsweek magazine said in 2010 that "For three decades, the LOA has done a splendid job of making good on" its initial goals. Writing for the New York Times Book Review, the essayist and teacher William Deresiewicz has referred to the Library of America as "our quasi-official national canon". Indeed, whether an American writer has achieved a level of greatness is sometimes associated with whether they have the imprimatur of the Library of America. Writing for The Sewanee Review, the academic Michael Gorra has said that "the Library has shaped and indeed expanded our sense of what counts as American literature ... what makes the Library of America so valuable is the risks it takes around the edges of what used to be American literature".
The Library of America has attracted a number of criticisms as well, including accusations of selection biases in favor of literary and political trends and the questionable inclusion of certain writers ostensibly non-canonical. An offshoot series put out in 1989 by Vintage Books that was associated with the Library of America name was faulted as overly commercial and exploitative. Even the marketing for the main series has been reproved as overbearing, in that it overstated the degree to which the preservation of American literature was in peril and the degree to which the Library of America was saving it.
The LOA has been satirized by the essayist Arthur Krystal as "confer[ing] value on writers by encasing their work in handsome black-jacketed covers with a stripe of red, white, and blue on the spine." The oft-perceived requirement that writers have passed from the scene led to one wry comment that "one sympathizes with the directors of a publishing venture increasingly dependent on the idea that great American writers just can't die fast enough." The series even prompted a mocking poem that began:
It's like heaven: you've got to dieTo get there. And you can't be sure.The publisher might go out of business.
In an April Fools' Day swipe at the Library of America's selection standards, another satirical piece proclaimed that the LOA "would publish volumes of Paris Hilton's and William Shatner's memoirs, and possibly those of Jersey Shores Snooki." Images of the faux volumes were included.
In his 2001 book Book Business: Publishing Past, Present, and Future, LOA co-founder Jason Epstein, who by his own account had lost out in an internal power struggle and departed the venture, sharply criticized the Library of America's finances and what he saw as the publication of unnecessary anthologies and authors whose qualifications for the series were suspect. He concluded:
The Library of America has now published substantially all the work for which it was created and for which rights are available. Its obligation hereafter is to husband its resources so that this work remains in print and accessible to readers, and to ensure that funds are on hand for the publication of twentieth-century writers as rights permit.
What Edmund Wilson would think of the series as it has evolved is unknowable, but writing for The Antioch Review in 1986, the fellow Paul M. Wright ventures that "We might reasonably infer that he would be pleased but not, I think, entirely pleased."
Less reservedly, the editor and commentator Norman Podhoretz, writing for Commentary in 1992, said that "the Library of America is as close to the kind of thing [Wilson] envisaged as it could conceivably be."
Build and manufacture
The designer of the appearance of Library of America books is Bruce Campbell. When the first LOA volumes appeared in 1982, the "Book Design & Manufacturing" column of Publishers Weekly headlined that the series's physical appearance was "a triumph of the bookmaker's art".
The LOA uses paper which meets guidelines for permanence originally set out by a committee of the Council on Library Resources and subsequently by the American National Standards Institute. Each volume is printed on thin but opaque acid-free paper, allowing books ranging from 700 to 1,600 pages to remain fairly compact (although not as small as those in La Pléiade). The paper used means the books will last a very long time without crumbling or yellowing. All volumes in the main series have the same trim size, by , which is based on the golden section. The weight of each volume is around .
For the hardcover editions, the binding cloth is woven rayon, and the books are Smyth-sewn. Each includes a ribbon bookmark. Pages in the books will lie flat when open. The uniform typeface is Galliard.
The LOA publishes selected titles in paperback, mainly for the college textbook market.
Main series
Special anthologies
Writing New York (Phillip Lopate, ed. 1998)
American Sea Writing (Peter Neill, ed. 2000)
Baseball (Nicholas Dawidoff, ed. 2002)
Writing Los Angeles (David L. Ulin, ed. 2002)
Americans in Paris (Adam Gopnik, ed. 2004)
American Writers at Home (J. D. McClatchy, author, Erica Lennar, photographer 2004)
American Movie Critics (Phillip Lopate, ed. 2006)
American Religious Poems (Harold Bloom and Jesse Zuba, eds., 2006)
American Food Writing (Molly O'Neill, ed., 2007)
True Crime: An American Anthology (Harold Schechter, ed., 2008)
Becoming Americans: Four Centuries of Immigrant Writing (Ilan Stavans, ed., 2009)
At the Fights: American Writers on Boxing (George Kimball and John Schulian, eds., 2011)
The 50 Funniest American Writers: An Anthology of Humor from Mark Twain to The Onion (Andy Borowitz ed., 2011)
Into the Blue: American Writing on Aviation and Spaceflight (Joseph J. Corn, ed., 2011)
The Cool School: Writing from America's Hip Underground (Glenn O'Brien, ed., 2013)
Football: Great Writing about the National Sport (John Schulian, ed., 2014)
Shake It Up: Great American Writing on Rock and Pop from Elvis to Jay Z (Kevin Dettmar and Jonathan Lethem, eds., 2017)
Basketball: Great Writing About America's Game (Alexander Wolff, ed., 2018)
Dance in America: A Reader's Anthology (Mindy Aloff, ed., 2018)
The Future Is Female! 25 Classic Science Fiction Stories by Women, from Pulp Pioneers to Ursula K. Le Guin (Lisa Yaszek, ed., 2018)
The Great American Sports Page: A Century of Classic Columns from Ring Lardner to Sally Jenkins (John Schulian, ed., 2019)
American Birds (Andrew Rubenfeld and Terry Tempest Williams, eds., 2020)
American Christmas Stories (Connie Willis, ed., 2021)
Women's Liberation! Feminist Writings that Inspired a Revolution and Still Can (Alix Kates Shulman and Honor Moore, eds., 2021)
The Future Is Female! More Classic Science Fiction Stories by Women (Lisa Yaszek, ed., 2022)
American poets project
American Wits: An Anthology of Light Verse (John Hollander, editor 2003)
Edna St. Vincent Millay: Selected Poems (J. D. McClatchy, editor 2003)
Edgar Allan Poe: Poems and Poetics (Richard Wilbur, editor 2003)
Poets of World War II (Harvey Shapiro, editor 2003)
Karl Shapiro: Selected Poems (John Updike, editor 2003)
Walt Whitman: Selected Poems (Harold Bloom, editor 2003)
Yvor Winters: Selected Poems (Thom Gunn, editor 2003)
John Berryman: Selected Poems (Kevin Young, editor 2004)
Kenneth Fearing: Selected Poems (Robert Polito, editor 2004)
Amy Lowell: Selected Poems (Honor Moore, editor 2004)
Muriel Rukeyser: Selected Poems (Adrienne Rich, editor 2004)
John Greenleaf Whittier: Selected Poems (Brenda Wineapple, editor 2004)
William Carlos Williams: Selected Poems (Robert Pinsky, editor 2004)
The Essential Gwendolyn Brooks (Elizabeth Alexander, editor 2005)
Emma Lazarus: Selected Poems (John Hollander, editor 2005)
Samuel Menashe: New and Selected Poems (Christopher Ricks, editor 2005)
Poets of the Civil War (J. D. McClatchy, editor 2005)
Theodore Roethke: Selected Poems (Edward Hirsch, editor 2005)
Edith Wharton: Selected Poems (Louis Auchincloss, editor 2005)
A. R. Ammons: Selected Poems (David Lehman, editor 2006)
Cole Porter: Selected Lyrics (Robert Kimball, editor 2006)
Louis Zukofsky: Selected Poems (Charles Bernstein, editor 2006)
American Sonnets (David Bromwich, editor 2007)
Kenneth Koch: Selected Poems (Ron Padgett, editor 2007)
Carl Sandburg: Selected Poems (Paul Berman, editor 2007)
Anne Stevenson: Selected Poems (Andrew Motion, editor 2007)
James Agee: Selected Poems (Andrew Hudgins, editor 2008)
Ira Gershwin: Selected Lyrics (Robert Kimball, editor 2009)
Poems from the Women's Movement (Honor Moore, editor 2009)
Stephen Foster & Co.: Lyrics of America's First Great Popular Songs (Ken Emerson, editor 2010)
Stephen Crane: Complete Poems (Christopher Benfey, editor 2011)
Countee Cullen: Collected Poems (Major Jackson, editor 2013)
Special publications
Isaac Bashevis Singer: An Album (Ilan Stavans, editor, 2004)
Farber on Film: The Complete Film Writings of Manny Farber (Robert Polito, editor, 2009)
Hub Fans Bid Kid Adieu: John Updike on Ted Williams (2010)
The Age of Movies: Selected Writings of Pauline Kael (Sanford Schwartz, editor, 2011)
The Collected Writings of Joe Brainard (Ron Padgett, editor, 2012)
Edgar Rice Burroughs, A Princess of Mars (2012) ; Tarzan of the Apes (2012)
American Pastimes: The Very Best of Red Smith (Daniel Okrent, editor, 2013)
The Top of His Game: The Best Sportswriting of W. C. Heinz (Bill Littlefield, editor, 2015)
President Lincoln Assassinated!! The Firsthand Story of the Murder, Manhunt, Trial, and Mourning (Harold Holzer, editor, 2015)
String Theory: David Foster Wallace on Tennis (2016)
My Dearest Julia: The Wartime Letters of Ulysses S. Grant to His Wife (2018)
Harold Bloom, The American Canon: Literary Genius from Emerson to Pynchon (David Mikics, editor, 2019)
Kate Bolick, Jenny Zhang, Carmen Maria Machado, and Jane Smiley, March Sisters: On Life, Death, and Little Women (2019)
Where the Light Falls: Selected Stories of Nancy Hale (Lauren Groff, editor, 2019)
The Peanuts Papers: Writers and Cartoonists on Charlie Brown, Snoopy and the Gang, and the Meaning of Life (Andrew Blauner, editor, 2019)
Walt Whitman Speaks: His Final Thoughts on Life, Writing, Spirituality, and the Promise of America, as Told to Horace Traubel (Brenda Wineapple, editor, 2019)
American Conservatism: Reclaiming an Intellectual Tradition (Andrew J. Bacevich, editor, 2020)
American Democracy: 21 Historic Answers to 5 Urgent Questions (Nicholas Lemann, editor, 2020)
The Collected Breece D'J Pancake: Stories, Fragments, Letters (2020)
Dolores Hitchens, Sleep with Strangers (2021) ; Sleep with Slander (2021)
Molière, The Complete Richard Wilbur Translations, volume 1 (2021) ; volume 2 (2021)
Mary Jane Ward, The Snake Pit (2021)
Richard Wright, The Man Who Lived Underground (2021)
Hannah Arendt, On Lying and Politics (2022)
Edward Hirsch, The Heart of American Poetry (2022)
Ronald L. Fair, Many Thousand Gone: An American Fable (2023)
Nancy Hale, The Prodigal Women (2023)
John A. Williams, The Man Who Cried I Am (2023)
Jay Parini, Robert Frost: Sixteen Poems to Learn by Heart (2024)
S. J. Perelman, Cloudland Revisited: A Misspent Youth in Books and Film (2024) ; Crazy Like a Fox (2024)
See also
Bibliothèque de la Pléiade
Notes and references
Further reading
External links
List of all main series titles
"Forty Years of the LOA Series: Top Volumes 1982–2022"
Nonprofit Explorer 501(c)(3) listings at ProPublica
1979 establishments in New York City
Book publishing companies of the United States
Book publishing companies based in New York City
Literary publishing companies
Non-profit publishers
Publishing companies established in 1979
Series of books
Editorial collections
Non-profit organizations based in New York City |
Elizabeth "Betsy" Watson was Houston's first female police chief. She served for two years before becoming the police chief in Austin, Texas, and then becoming a law enforcement consultant.
Early life
Watson grew up in Philadelphia but attended high school in Houston, after graduating from college and joining HPD, she met Chase in late 1973 when they were both assigned to the Houston jail, and they began dating the following spring. Since such fraternization was frowned upon, they used a police scuba-diving club as a cover. They married in 1976, the same day she was promoted to Detective.
Education
She received a degree in psychology from Texas Tech University in 1971.
Career
Immediately after graduating, she applied for the Houston Police Department, graduating at the top of her class.
She commented that it was tough to be a female officer at the time, and her husband had coaxed her to take, and pass, the Lieutenant's exam after she was forced out of burglary division. To make up for her lack of street experience, she volunteered for night shift duty at some of the city's roughest substations.
As deputy chief, she commanded the West Side Command Station, the first of five planned stations that are the cornerstone of Chief Brown's program to decentralize police work and make it more responsive to the community.
When she was tapped to be the Chief, she would inherit a police force in turmoil or low morale attributed to low pay and a public mistrust of the police due to some recent shootings.
With the swearing in of Sam Nuchia as the chief, Watson was demoted to assistant chief earlier in the year, she took up a position at National Institute of Justice where she worked as a researcher and adviser. The institute compensated the city for salary and benefits until Watson is eligible for retirement in December and She will be commuting between Washington, D.C. and Houston.
A few weeks later, Watson announced that she would be taking the police chief's position at the Austin Police Department, However, she said that she would be unable to take the position until December 5, which is the date that she would complete her 20-year status, and therefore is eligible for retirement pay.
On December 5, 1992, Watson was sworn in as chief of police at Austin, Texas. She would resign in 1997 after a tenure racked with turmoil, police shortages, and other controversies.
References
External links
Houston Police Department chiefs
Texas Tech University alumni
Living people
People from Houston
People from Austin, Texas
People from Philadelphia
Year of birth missing (living people) |
The A1173 is a Primary Route that runs from The A46 road in Caistor to the A160 road in Immingham. It is 11 miles long.
References
Roads in England |
William Edward Barton (3 November 1858 – 15 September 1942) was a New Zealand cricketer who played ten first-class matches for West Coast and Auckland in the 1880s. During his career he was widely considered to be the best batsman in New Zealand.
Life
Born in England, Barton was educated at Cranleigh School in Surrey, where he was coached at cricket by the professional players Harry Jupp and James Street. He migrated to New Zealand on the ship St Leonards, arriving in November 1877, and worked for the Bank of New Zealand, first in Wanganui, then in Auckland from 1882, in Blenheim from early 1888, in Whangarei from late 1888, in Kaikōura from 1895, then as manager of the Rangiora branch from 1906. He retired in 1920, having served the bank for 43 years.
Barton married Eva Hamlin Stevens at St Mark's Anglican Church in the Auckland suburb of Remuera in November 1888. Both choristers since their youth, they were members of the choir of St John's Church in Rangiora for more than 30 years. They had one son, Frederick, born in Whangarei in 1891. Eva died at home in Rangiora on 29 July 1938. Barton died at his brother's home in the Christchurch suburb of Redcliffs on 15 September 1942.
Cricket career
The New Zealand cricketer Dan Reese considered Barton the first great New Zealand batsman. He singled out Barton's performance for the Wanganui XXII against the 1880–81 Australian XI, when he scored 44 out of the 85 required to win, against the bowling of Fred Spofforth, Harry Boyle and Joey Palmer, in a match in which 51 wickets fell for 266 runs.
Barton's representative career began in November 1879 when, in a one-day match, he scored 67 for Wanganui against Wellington, in a match in which 40 wickets fell for 271 runs. A few weeks later, in his first first-class match, he scored 75 not out ("a grand innings without a ghost of a chance") out of West Coast's first innings of 120 in a victory over Wellington. No other batsman in the match exceeded 26. It was West Coast's only first-class match. Dan Reese later wrote: "For a couple of years ... Wanganui cricket reached first-class standard, chiefly on account of Barton, then the best batsman in New Zealand, being resident there. But neither before nor since have they been first-class."
Barton began representing Auckland soon after moving to work there in 1882. In a two-day match for Auckland against a Dunedin combined team in 1882–83, Barton opened the batting and carried his bat for 76 out of a total of 150; no one else in the match reached 35. A Dunedin cricket journalist later described Barton as "probably the finest batsman who has settled in the colony", a batsman "of uncommon brilliancy". Playing for Auckland against Taranaki later that season, he opened the batting and scored 74; no one else in the match reached 50. The Auckland Star commented that his innings showed why Barton had "the reputation of being the best batsman in the colony".
He made his highest first-class score of 83 for Auckland against Wellington in 1884–85, once again the highest score in the match: "The Auckland crack had played a magnificent innings, his hitting on both sides being well timed and judicious, his leg strokes being made in his very best form."
In 1884-85 Barton set a record for the highest score in a senior match in New Zealand when he made 190 for the Auckland Cricket Club; it was surpassed later in the season by a batsman in Christchurch who made 220. In all matches in 1884-85 he scored 922 runs at an average of 48.54, including three centuries for the Auckland club. In a match in January 1886, Barton, "a cricketer who has not been equalled in New Zealand for the number of centuries he has scored", made 195 for the Auckland club. In less than six seasons of cricket in Auckland he scored more than 4000 runs at an average above 40, with "nearly a dozen" centuries.
In early 1886 there was speculation that Barton might be included in the Australian team to tour England that year. The Sydney Globe newspaper recommended his inclusion, and the leading Australian Test player Jack Blackham also raised the possibility. However, the Melbourne Cricket Club, which was organising the tour, decided that selection would be limited to residents of Australia. It was the first time a New Zealander had been considered for Australian selection.
Barton was one of the first batsmen to play the pull shot to balls on the off-stump, a shot later popularised by George Hirst in England. He was one of the 14 players chosen in 1927 by the New Zealand cricket historian Tom Reese as the best New Zealand cricketers before the First World War.
Other sports
As well as cricket, which Barton played for 40 years, he also excelled at lawn tennis, representing Auckland at the New Zealand Championships in December 1887. He was the inaugural winner of the Auckland Tennis Championship in 1886, and won again in 1888. In 1886 he had been undefeated in singles matches in New Zealand for eight years.
Barton was also a prominent track-and-field athlete, a champion croquet player, and a rugby union player and referee. He also took part in bowls, golf, rowing and hunting.
References
External links
1858 births
1942 deaths
People educated at Cranleigh School
British emigrants to the Colony of New Zealand
New Zealand cricketers
New Zealand male tennis players
Auckland cricketers
West Coast cricketers
Sportspeople from the Colony of New Zealand |
Rex Deeath (born 9 March 1949) is a former Australian rules footballer who played for Geelong in the Victorian Football League (now known as the Australian Football League).
References
External links
1949 births
Living people
Geelong Football Club players
Geelong West Football Club players
Australian rules footballers from Victoria (state)
People educated at Geelong College |
The 2012–13 Oregon Ducks men's basketball team represented the University of Oregon during the 2012–13 NCAA Division I men's basketball season. The Ducks, led by their third year head coach Dana Altman, were members of the Pac-12 Conference and played their home games at Matthew Knight Arena. They finished with a record of 28–9 overall, 12–6 in Pac-12 play to finish in a three-way tie for second place. They were champions of the Pac-12 tournament, defeating UCLA in the championship game, to earn an automatic bid to the 2013 NCAA tournament where they defeated Oklahoma State in the second round and Saint Louis in the third round to advance to the Sweet Sixteen where they lost to Louisville.
Recruits
Source:
Roster
Depth chart
Schedule
|-
!colspan=9| Exhibition
|-
!colspan=9| Regular season
|-
!colspan=6 style="background:#004F27; color:yellow;"| Pac-12 tournament
|-
!colspan=6 style="background:#004F27; color:yellow;"| NCAA tournament
Notes
On March 12, 2013 Dana Altman was named the John R. Wooden Pac-12 head coach of the year.
References
Oregon Ducks men's basketball seasons
Oregon
Oregon
Oregon Ducks men's baske
Oregon Ducks men's baske
Pac-12 Conference men's basketball tournament championship seasons |
The Great Eastern Railway (GER) Class G14 was a class of 2-4-0 steam locomotives.
The Class G14 was designed by Thomas William Worsdell for the express service from London to Norwich, the first locomotive produced while he was superintendent. A total of 20 were built, 562–564 in late 1882 and the rest in 1883.
Details
The locomotive was designed for the Great Eastern Railway's London to Norwich route on which the frequent sharp curves between London and Cambridge necessitated that the wheelbase not be entirely rigid, so a radial axle box was fitted to the front wheels giving 1 1/2 inches of side motion each way controlled by a horizontal elliptical spring. It used Joy valve gear, with the valves placed on top of the cylinders, allowing them to be brought closer together allowing larger cylinders and longer bearings, the Joy valve motion having the benefit of not requiring space on the crankshaft for eccentrics.
The locomotives were numbered 562 to 571, and 640 to 649, 20 in total.
Accidents/Incidents
In Swaffham, on 31 January 1894, G14 No. 567 managed to either run across the turntable, or reverse out of it instead of moving forward, and crashed through the buffer stops and down a steep bank tender first. The locomotive fortunately being saved by the tender which jammed between the rear of the locomotive and the road below that separated the engine yard from Northwell Pool.
References
2-4-0 locomotives
G14
Railway locomotives introduced in 1882
Standard gauge steam locomotives of Great Britain
Scrapped locomotives |
Kristin K. Devold (born 2 October 1939) is a Norwegian politician for the Conservative Party.
She served as a deputy representative to the Norwegian Parliament from Møre og Romsdal during the term 1989–1993. In total she met during 27 days of parliamentary session.
References
1939 births
Living people
Deputy members of the Storting
Conservative Party (Norway) politicians
Møre og Romsdal politicians
Women members of the Storting
Place of birth missing (living people)
20th-century Norwegian women politicians |
The Great Seal of the State of Hawaii was designated officially by Act 272 of the 1959 Territorial Legislature and is based on the territorial seal. Modifications to the territorial seal included the use of the words "State of Hawaii" at the top and "1959" within the circle. Provisions for a seal for the state of Hawaii were enacted by the Territorial Legislature and approved by Governor William F. Quinn on June 8, 1959. The passage of the Admission Act in 1959, admitted Hawaii as the 50th State of the United States of America on August 21, 1959.
The seal of the Territory of Hawaii was the same as the seal of the republic, except that it had "Territory of Hawaii" placed at the top and "1900" (signifying the year that the territorial government officially was organized) within the circle. The 1901 Territorial Legislature authorized the modified republic seal as the Seal of the Territory of Hawaii.
The seal of the Republic of Hawaii had the words "Republic of Hawaii" at the top and "MDCCCXCIV" within the circle. The year 1894 signified the date that the republic was established. The republic seal was designed by Viggo Jacobsen, a Honolulu resident, and itself was derived from the Royal Arms of the Kingdom of Hawaii used during the reigns of King Kamehameha III, King Kalākaua and Queen Liliuokalani, which had been designed by the College of Arms in London in 1842 and officially adopted in 1845.
State Seal
The Great Seal of the State of Hawaii is circular in shape, two and three-quarters inches in diameter, and of the design being described, with the tinctures added as the basis for the coat of arms. The Hawaii state seal represents Hawaii's nation.
Coat of arms
In the center of the seal is a heraldic shield which is quartered. The blazon is as follows
Quarterly, 1st and 4th, barry of eight Argent, Gules, and Azure; 2nd and 3rd, Or, a puloulou or sacred staff proper; en surtout, an inescutcheon Vert charged with a mullet Or.
Supporters design
On the left side is King Kamehameha I, standing in the as represented by the bronze statue in front of Ali'iolani Hale, Honolulu. His cloak and helmet (a mahiole) are in yellow. Kamehameha I's figure is in proper. Kamehameha I unified the Hawaiian Islands into a single united kingdom. On the right side is goddess Liberty also wearing a Phrygian cap and laurel wreath. She is holding Ka Hae Hawaii in her right hand that is partly unfurled.
Crest design
A rising sun irradiated in gold surrounded by the legend "State of Hawaii, 1959" on a scroll in black lettering.
Motto design
The state motto: Ua Mau ke Ea o ka ʻĀina i ka Pono is on the scroll on the seal's bottom in gold lettering. Ua Mau ke Ea o ka ʻĀina i ka Pono is roughly translated into English as "The life of the land is perpetuated in righteousness." The motto was adopted by the Kingdom of Hawaii in 1843 and was used in an address by King Kamehameha III at ceremonies following the return of his kingdom from the British. British captain Lord George Paulet of demanded that Hawaii was ceded to Great Britain in response to claims of political abuses against British residents made by British Consul Richard Charlton. After Kamehameha III notified London of the captain's actions, Admiral Richard Darton Thomas returned sovereignty back to the King. The motto is also featured in Israel Kamakawiwo'ole's song "Hawaii '78" and is used on the Hawaii state quarter.
Compartment design
Below the heraldic shield, the bird phoenix has it wings outstretched arising from flames. The phoenix's body is black and wings half yellow and half dark red. Below the heraldic shield are eight taro leaves having on either side banana foliage and sprays of maidenhair fern trailed upwardly.
Symbolism
1959 represents the year of admission into the Union as a state.
The rising sun replaced the royal crown from the original coat of arms. This represents the birth of a new state.
King Kamehameha the Great and the Goddess of Liberty holding the Hawaiian flag replace the two warriors on the Royal Arms. This may represent the old government leader (King Kamehameha the Great) and the new government leader (The Goddess of Liberty).
The quartered design of the heraldic shield is retained from the original coat of arms.
The eight stripes in two of the quarters of the shield represent the eight main islands.
The Puloulou, or tabu ball and stick, in the second and third quarters was carried before the king and placed before the door of his home, signifying his authority and power. In the seal it is a symbol of the authority and power of the government.
The star in the middle of the shield signifies the fiftieth star added to the United States flag.
The phoenix, symbol of death and resurrection, symbolizes the change from an absolute monarchy to a free, democratic form of government.
The eight taro leaves, flanked by banana foliage and maidenhair fern are typical Hawaiian flora and represent the eight main islands. Taro is the traditional staff of life and has great spiritual significance. Taro is also still cultivated and is the ingredient of the popular dish called poi.
The state motto, "Ua Mau ke Ea o ka ʻĀina i ka Pono", "The life of the land is perpetuated in righteousness," is retained from the royal coat of arms.
Government seals of Hawaii
See also
Coat of Arms of the Hawaiian Kingdom - The historical coat of arms of Hawaii
References
External links
The Great Seal of the State of Hawai'i
Symbols of Hawaii
Hawaii
Hawaii
Hawaii
Hawaii
Hawaii
Hawaii
Hawaii
Hawaii
Hawaii |
Afrochilis insularis is the only known member of the genus Afrochilis of the family Machilidae, which is from the order Archaeognatha. It is endemic to the Socotra archipelago, a group of isolated islands.
References
Archaeognatha
Endemic fauna of Socotra
Insects described in 2001 |
4 Field Survey Squadron (4 Fd Svy Sqn) was a field survey (topographic) unit of the Australian Army and the Royal Australian Survey Corps (RA Svy) based in Adelaide SA. Raised in February 1952 it was disbanded on 1 May 1996. The unit's role was to conduct geodetic surveys, topographic surveys, compile and cartographically complete topographic maps, acquire aerial mapping photography and to distribute topographic products for land combat operations. The unit's primary area of responsibility was South Australia and Northern Territory but the squadron was tasked for operations in Queensland, Victoria, Papua New Guinea (1972–1974) and nations in the south west Pacific area (1986–1994).
Organisation
A systematic military survey program commenced in Australia in 1910. Early field surveys and mapping were concentrated around capital cities and important port facilities. In the late-1920s a sub-section of the Survey Section – Royal Australian Engineers (Permanent) moved from Brisbane, QLD to Adelaide, SA to commence work there.
During the Second World War there were no Army survey units based in South Australia but military survey maps were produced as part of the emergency mapping program in collaboration with the State Lands Department. In the Northern Territory 7th Field Survey Section was relieved in April 1943 by 1 Section, 6th Army Topographic Survey Company after serving for two years in that theatre. 1 Section remained in Northern Australia until war's end.
From 1946 to 1951 Army Headquarters (AHQ) Field Survey Section (Melbourne VIC) and a detachment from 5th Field Survey Company (Sydney NSW) conducted surveys in South Australia for nationally important projects such as the Woomera Rocket Range and industrial development around the upper Spencer Gulf areas of Whyalla, Port Augusta and Port Pirie. AHQ Field Survey Section (Central Command Detachment) with an establishment of three officers and twenty-two other ranks was formed in Adelaide at Largs Bay in February 1952 to take responsibility for mapping of Woomera and military mapping in all parts of the state. The section was redesignated Central Command Field Survey Section in 1953 moving into Hampstead Barracks and then moving to Keswick Barracks in 1954. The unit was redesignated Central Command Field Survey Unit in 1961 moving to the old cavalry stables in what became a part of a purpose built facility occupied in 1973. In 1970 the unit was redesignated 4th Field Survey Squadron with an increased establishment of five officers and seventy-five other ranks until that was reduced in the mid-1970s to five officers and forty-seven other ranks. In 1973 command of the unit moved from the regional command (HQ 4th Military District – Keswick Barracks, Adelaide, SA) to the functional command structure under HQ Field Force Command – Victoria Barracks, Sydney, NSW. This organisation remained until the major Corps restructure in 1989/90 when the unit was the only remaining Corps field survey unit in Australia and was moved under the command of the Army Survey Regiment. At this time it was increased in strength to nine officers and sixty-eight other ranks. Command changed again in 1993 when 4 Fd Svy Sqn was again a direct command unit of Land Command until it was disbanded in 1996. On disbandment the personnel establishment was transferred to augment 1st Topographic Survey Squadron to enhance the field deployable survey capability.
Operations
All four Australian based field survey squadrons (1,2,4 and 5 Fd Svy Sqns) had the capability to conduct geodetic and topographic surveys, compile maps to the pre-cartographic draughting stage from aerial photography using photogrammetric methods, field check preliminary maps and acquire aerial photography to identify survey stations. From the late-1970s field survey units could cartographically complete maps to the pre-press stage. From 1990, 4 Fd Svy Sqn had the capability to acquire large-block mapping quality aerial photography.
From 1981 to 1994 personnel from the squadron co-operated the joint Aust/US permanent fixed Global Positioning System (GPS) station at Smithfield SA.
In addition to standard survey and mapping operations, the squadron was responsible for surveys and mapping of military training areas and defence installations and was routinely tasked with a miscellany of survey work.
The units' operations 1946 to 1995 were summarised by the last Officer Commanding, Major Peter Demaine, in an article in the Canberra Survey Corps Association Newsletter.
Topographic surveys for scale 1:100,000 topographic mapping in the Northern Territory (1967-1968) and Territory of Papua and New Guinea (1972-1974) were conducted primarily by airborne distance measurement systems Aerodist MRC2 and MRB3/201.
See also
Royal Australian Survey Corps
8th Field Survey Squadron
Footnotes
Citations
Military units and formations of the Australian Army
Surveyors |
```smalltalk
namespace ReClassNET.MemoryScanner.Comparer
{
public interface IScanComparer
{
ScanCompareType CompareType { get; }
}
}
``` |
The Temples Order 1971 is an Order in Council in the United Kingdom, setting out the powers of the Inner Temple and Middle Temple to act as local authorities.
References
Inns of Chancery
History of the City of London
Orders in Council
1971 in British law
Order 1971 |
Bodmin St Petroc was an electoral division of Cornwall in the United Kingdom which returned one member to sit on Cornwall Council between 2013 and 2021. It was abolished at the 2021 local elections, being succeeded by the larger Bodmin St Petroc's.
Extent
Bodmin St Petroc represented the east side of Bodmin, the hamlet of Cooksland, and parts of the hamlet of Fletchersbridge (which was shared with Lanivet and Blisland). The division covered 752 hectares in total.
Election results
2017 election
2013 election
References
Electoral divisions of Cornwall Council
Bodmin |
John Gidding (born January 7, 1977) is a Turkish-American designer, television personality, and former fashion model.
Gidding started modeling in 2000 as a graduate student, performing runway shows for Armani, Gucci, and Hugo Boss before being represented by Wilhelmina Models in New York City. Before entering the design profession, Gidding was the spokesmodel for Jhane Barnes in 2004 and 2005. He has also been on the covers of numerous romance novels.
He was voted one of "Yale's 50 Most Beautiful People" in 1999 by Rumpus Magazine, one of "Boston's 50 Most Eligible Bachelors" by The Improper Bostonian in 2002, one of "Atlanta's 50 Most Beautiful People" by Jezebel Magazine and as one of Atlanta Homes and Lifestyles's "Emerging Talent: Twenty Under 40" in 2008.
Biography
Gidding was born in Istanbul, Turkey, to an American father and a Turkish mother.
He lived in Turkey until moving to the United States for college after attending Leysin American School in Leysin, Switzerland. He graduated from Yale University in 1999 with a BA in architecture, then the Harvard Graduate School of Design with a Master's in architecture. At Yale he sang a cappella with The Society of Orpheus and Bacchus, and choral music with the Yale Glee Club, and at Harvard he sang with the Harvard-Radcliffe Collegium Musicum.
Gidding moved to New York City, where he started John Gidding Design, Inc. after working for two years as a designer for Michael Van Valkenburgh Associates.
Gidding's start in television was with the ABC Family TV show Knock First, where he and three other designers took turns making over teenagers' bedrooms. Designed to Sell (Giddings' previous show from 2006 to 2011) was cancelled in early 2011 by HGTV, and Knock First is still running in syndication internationally.
He is best known as the designer on Curb Appeal: The Block where his team spent $20,000 on improvements to the exterior and landscaping of chosen homeowners. Less expensive touch-ups were done for 2 or 3 nearby neighbors' homes to improve overall neighborhood property values.
In 2015 he was one of the expert judges on the Fox TV show Home Free. He joined the reboot of Trading Spaces, joining the cast alongside Paige Davis and Vern Yip. He is currently back on HGTV, with a relaunch of the popular franchise, Curb Appeal Xtreme.
Personal life
Gidding was married to ballet dancer Damian Smith. The two later divorced.
References
External links
The Official John Gidding website
HGTV's Designed to Sell
1977 births
Turkish people of American descent
Turkish emigrants to the United States
American male models
American architects
American LGBT entertainers
American LGBT models
Living people
Yale University alumni
Harvard Graduate School of Design alumni
Turkish LGBT entertainers
Turkish LGBT models
Turkish male models
LGBT architects
Gay models
LGBT people from New York (state)
Turkish architects
American expatriates in Switzerland
Turkish expatriates in Switzerland
Gay entertainers |
The Parnall 382 was a 1930s British single-engined monoplane trainer aircraft with two open cockpits, designed and developed by Parnall Aircraft Ltd.
Design and development
The Parnall 382 was designed to meet UK Air Ministry Specification T.1/37 for an 'ab initio' trainer, and was also known as the Parnall Heck III. Its competitors were the Heston T.1/37 and the Miles M.15. The Airspeed AS.36, General Aircraft GAL.32 and Percival P.20 were also proposed against specification T.1/37, but not accepted or built. None of the designs was selected for production orders; it has been suggested that the required performance could not be achieved within the constraints of the Specification.
Construction was primarily wooden, with plywood-skinned spruce frames. The cantilever oleo-pneumatic fixed main undercarriage legs were faired with spats. The undercarriage, tail unit and outer wing panels were adapted from the Parnall Heck 2C. The propeller was a de Havilland fixed-pitch type. Student and tutor sat in open, tandem cockpits, but the rear cockpit was later enclosed.
Operational history
One example of the Parnall 382 was built by Parnall Aircraft Ltd as a private venture project. The first flight was by G.A.C Warren at Yate Aerodrome in February 1939, with B conditions registration J1. In September 1939 it was registered G-AFKF. In June 1941, as the Parnall Heck III, it was allocated serial R9138 under contract 23979/39. In trials at the Aeroplane & Armament Experimental Establishment (A&AEE) at Martlesham Heath, it was assessed as pleasant to fly and generally good as a trainer. Notwithstanding a few modifications, no order was forthcoming, and it was SOC (struck off charge) on 5 March 1943. It was allocated the serial 3600M and ended its days as an Air Training Corps instructional airframe at Jones' West Monmouth School, Pontypool.
Specifications
References
1930s British military trainer aircraft |
Sphodromantis congica, common name Congo mantis is a species of praying mantis found in Angola, Nigeria, and the Congo River region.
See also
African mantis
List of mantis genera and species
References
Congica
Mantodea of Africa
Insects of Angola
Insects of Cameroon
Insects of the Central African Republic
Insects of the Democratic Republic of the Congo
Insects of Ethiopia
Insects of Gabon
Insects of West Africa
Insects of the Republic of the Congo
Insects described in 1931 |
Nowe Sady may refer to places in Poland:
Nowe Sady, Opole Voivodeship
Nowe Sady, Subcarpathian Voivodeship
Nowe Sady, Warmian-Masurian Voivodeship |
The Southern Writers Conference was held at the University of Virginia in 1931 to discuss “The Relation of the Southern Author to His Public.” It was organized by Virginia Quarterly Review editor James Southall Wilson and presided over by Ellen Glasgow and DuBose Heyward. Notable attending writers included Sherwood Anderson, James Branch Cabell, Dubose Heyward, Paul Green, Allen Tate, Caroline Gordon, Donald Davidson, Mary Johnston, James Boyd, Struthers Burt, Josephine Pinckney, and William Faulkner.
References
American writers' organizations
1931 in Virginia
University of Virginia |
Please add names of notable painters with a Wikipedia page, in precise English alphabetical order, using U.S. spelling conventions. Country and regional names refer to where painters worked for long periods, not to personal allegiances.
Betye Saar (born 1926), American assemblage artist
Gaetano Sabatini (1703–1734), Italian draftsman and painter
Jacques Sablet (1749–1803), French painter
Pieter Jansz Saenredam (1597–1665), Dutch painter and muralist
Cornelis Saftleven (1607–1681), Dutch painter
Herman Saftleven (1609–1685), Dutch painter
Sara Saftleven (1645–1702), Dutch painter
Kay Sage (1898–1963), American artist and poet
Anne Said (1914–1995), English artist
Jean-Pierre Saint-Ours (1752–1809), Swiss painter
Saitō Kiyoshi (斎藤清, 1907–1997), Japanese sōsaku-hanga artist
Sakai Hōitsu (酒井抱一, 1761–1828), Japanese painter
Adam Saks (born 1974), Danish painter
Emilio Grau Sala (1911–1975), Spanish (Catalan)/French painter and illustrator
Tahir Salahov (1928–2021), Soviet (Azerbaijani)/Russian painter and draftsman
Stanislaw Samostrzelnik (1480–1541), Polish painter, decorator and Cistercian monk
Joop Sanders (1921–2023), Dutch–American painter and educator
Hans Sandreuter (1850–1901), Swiss artist and designer
Bernat Sanjuan (1915–1979), Spanish (Catalan) painter and sculptor
John Singer Sargent (1856–1925), American painter and draftsman
Michael Aloysius Sarisky (1906–1974), Hungarian/American Hungarian painter
Andrea del Sarto (1487–1531), Italian painter
Arthur Sarkissian (born 1960), Armenian painter
Martiros Saryan (1880–1972), Armenian painter
Wilhelm Sasnal (born 1972), Polish painter, illustrator and film-maker
Satake Yoshiatsu (佐竹義敦, 1748–1785), Japanese painter and feudal lord
Junpei Satoh (佐藤淳平, born 1956), Japanese painter
Raymond Saunders (born 1934), American assemblage artist and draftsman
Antonio Saura (1930–1998), Spanish painter and writer
Anne Savage (1896–1971), Canadian painter and art teacher
Jacob Savery (1566–1603), Flemish/Dutch painter, etcher and draftsman
Roelant Savery (1576–1639), Dutch painter
Jenny Saville (born 1970), English painter
Konstantin Savitsky (1844–1905), Russian painter
Alexei Kondratyevich Savrasov (1830–1897), Russian painter
János Saxon-Szász (born 1964), Hungarian creative artist
Sawa Sekkyō (沢雪嶠, fl. late 18th/early 19th centuries) Japanese painter
Jan Sawka (born 1946), Polish/American artist and architect
Fikret Muallâ Saygı (1903–1967), Turkish painter
Godfried Schalcken (1643–1706), Dutch painter
Louis Schanker (1903–1981), American artist
Hugo Scheiber (1873–1950), Hungarian/German painter
Egon Schiele (1890–1918), Austrian painter
Oszkar Tordai Schilling (fl. late 19th century), Hungarian etcher and draftsman
Jakub Schikaneder (1855–1924), Austro-Hungarian (Bohemian)/Czechoslovak painter
Helene Schjerfbeck (1862–1946), Finnish painter
Rudolf Schlichter (1890–1955), German painter
Richard Schmid (born 1934), American artist
Georg Friedrich Schmidt (1712–1775), German engraver and designer
Johann George Schmidt (1707–1774), German Baroque architect
Hans Werner Schmidt (1859–1950), German painter, illustrator and etcher
Karl Schmidt-Rottluff (1884–1976), German painter and print-maker
Ruth Schmidt Stockhausen (1922-2014), German painter, graphic artist and sculptor
Randall Schmit (born 1955), American painter
Stella Schmolle (1908–1975), English painter
Julian Schnabel (born 1952), American painter and film-maker
Wilhelm Schnarrenberger (1892–1966), German painter
Gérard Ernest Schneider (1896–1986), Swiss painter
Georg Scholz (1890–1945), German painter
Floris van Schooten (1590–1655), Dutch painter
Otto Marseus van Schrieck (1619–1678), Dutch painter
Georg Schrimpf (1889–1938), German painter and graphic artist
Adolf Schrödter (1805–1875), German painter and illustrator
Daniel Schultz (1615–1683), Polish-Lithuanian painter
Ethel Schwabacher (1903–1984), American painter
Carlos Schwabe (1877–1926), Swiss painter and print-maker
Randolph Schwabe (1885–1948), English painter and etcher
Hans Schwarz (1922–2003), Austrian portrait painter
Kurt Schwitters (1887–1948), German artist
Alexander Scott (1872–1932), English/American painter
Caroline Lucy Scott (1784–1857), English landscape painter and novelist
Kathleen Scott (1878–1947), English sculptor
Peter Scott (1909–1989), English artist and conservationist
Richard T. Scott (born 1980), American history painter and writer
Samuel Scott (1703–1772), English painter and etcher
Tom Scott RSA (1854–1927), Scottish painter
William Edouard Scott (1884–1964), American artist
Eduardo Lefebvre Scovell (1864–1918), English/American artist
Sean Scully (born 1945), Irish/American painter, sculptor and photographer
Felipe Seade (1912–1969), Uruguayan painter and teacher
Otakar Sedloň (1885–1973), Austro-Hungarian (Czech)/Czechoslovak painter
Richard Sedlon (1900–1991), American painter
Lasar Segall (1891–1957), German/Brazilian painter, engraver and sculptor
Daniel Seghers (1590–1661), Flemish painter and Jesuit brother
Gerard Seghers (1591–1651), Flemish painter and art collector
Hercules Seghers (1589–1638), Dutch painter and print-maker
Kurt Seligmann (1900–1962), Swiss/American painter and engraver
Manuel Rendón Seminario (1894–1982), French/Ecuadorian painter
Jacek Sempoliński (born 1927), Polish painter, draftsman and critic
Sengai (仙厓義梵, 1750–1837), Japanese sumi-e painter
Sohrab Sepehri (1928–1980), Iranian poet and painter
Zinaida Serebriakova (1884–1967), Russian/French painter
Valentin Aleksandrovich Serov (1865–1911), Russian painter
Clément Serveau (1886–1972), French painter, engraver and illustrator
Bela Čikoš Sesija (1864–1931), Austro-Hungarian (Croat)/Yugoslav painter, art teacher and academy founder
Sesshū Tōyō (雪舟等楊, 1420–1506), Japanese ink and wash painter
James Sessions American painter (1882-1962)
Henriett Seth F. (born 1980), Hungarian artist, poet and musician
Georges Seurat (1859–1891), French artist
Gino Severini (1883–1966), Italian painter
Joseph Severn (1793–1879), English painter
Shang Xi (商喜, fl. c. 1430–1440), Chinese painter
Emily Shanks (1857–1936), Russian/English painter
Charles Haslewood Shannon (1863–1937), English painter and lithographer
Shao Mi (邵彌, c. 1592–1642), Chinese painter, calligrapher and poet
Harold Shapinsky (1925–2004), American painter
Tōshūsai Sharaku (東洲斎写楽, 1794–1795), Japanese ukiyo-e print designer
Sylvester Shchedrin (1791–1830), Russian painter
Millard Sheets (1907–1989), American artist, teacher and administrator
Samuel Shelley (1750–1808), English miniaturist
Rupert Shephard (1909–1992), English painter and illustrator
Shen Che-Tsai (沈哲哉, 1926–2017), Chinese (Taiwanese) painter
Shen Quan (沈銓, 1682–1760), Chinese painter
Shen Shichong (沈士充, fl. 14th, 15th or 16th century), Chinese painter
Shen Zhou (沈周, 1427–1509), Chinese painter
Sheng Mao (盛懋, fl. late 13th or 14th century), Chinese painter
Sheng Maoye (盛茂燁, fl. 14th, 15th or 16th century), Chinese painter
Shi Rui (石銳, fl. 14th or 15th century), Chinese painter
Shi Zhonggui (史忠貴, born 1954), Chinese painter, philosopher and poet
Shiba Kōkan (司馬江漢, 1747–1818), Japanese painter and print-maker
Shibata Zeshin (司馬江漢, 1807–1891), Japanese painter and lacquer and print artist
Kitao Shigemasa (北尾重政, 1739–1820), Japanese ukiyo-e painter
Shōzō Shimamoto (嶋本昭三, born 1928), Japanese artist
Kanzan Shimomura (下村 観山, 1873–1930), Japanese nihonga painter
Siona Shimshi (born 1939), Israeli painter, sculptor and ceramicist
Shin Saimdang (신사임당, 1504–1551), Korean artist, calligraphist and poet
Shin Yun-bok (신윤복, 1758–1813), Korean painter
Shingei (真芸, 1431–1485), Japanese yamato-e painter
Everett Shinn (1876–1953), American painter
Shinoda Toko (篠田桃紅, born 1913), Japanese sumi ink painter and print-maker
Ivan Shishkin (1832–1898), Russian painter
Shitao (石濤, 1642–1707), Chinese painter
Harry Shoulberg (1903–1995), American painter
Shūbun Tenshō (天章周文, died c. 1444–1450), Japanese painter and Zen Buddhist monk
Shukei Sesson (雪村, 1504–1589), Japanese painter and Zen monk
Kevin A. Short (born 1960), American painter and print-maker
Edward Scrope Shrapnel (1845-1920), Canadian painter
Ram Chandra Shukla (born 1925), Indian painter and art critic
Shunbaisai Hokuei (春梅斎北英, died 1837), Japanese ukiyo-e woodblock print-maker
Shunkōsai Hokushū (春好斎北洲, fl. 1802–1832), Japanese ukiyo-e woodblock print-maker
Walter Sickert (1860–1942), English painter and print-maker
Gregorius Sickinger (1558–1631), Swiss painter, draftsman and engraver
Henryk Siemiradzki (1843–1902), Polish/Italian painter
Paul Signac (1863–1935), French painter
Telemaco Signorini (1835–1901), Italian artist
Ramón Silva (1890–1919), Argentine painter
Sim Sa-jeong (심사정, 1707–1769), Korean painter
Josef Šíma (1891–1971), Austro-Hungarian (Czech)/Czechoslovak painter
Hugo Simberg (1873–1917), Finnish painter and graphic artist
Józef Simmler (1823–1868), Polish painter
Sidney Simon (1917–1997), American painter, sculptor and war artist
Edward Simmons (1852–1931), American painter and muralist
Enrique Simonet (1866–1927), Spanish painter
David Simpson (born 1928), American painter
Ruth Simpson (1889–1964), English painter
William Simpson (c. 1818 – 1872), African American portrait painter.
Oliver Sin (born 1985), Hungarian painter and science illustrator
Sin Wi (신위, 1769–1847), Korean painter and scholar
David Alfaro Siqueiros (1896–1974), Mexican painter and muralist
Mario Sironi (1885–1961), Italian painter
Alfred Sisley (1839–1899), French painter
Michael Sittow (1469–1525), Netherlandish/Spanish royal painter
Robert Sivell (1888–1958), Scottish painter
Archibald Skirving (1749–1819), Scottish portrait painter
P.C. Skovgaard (1817–1875), Danish painter
Antonín Slavíček (1870–1910), Austro-Hungarian (Czech) painter
Fyodor Slavyansky (1817–1876), Russian painter
Sylvia Sleigh (1916–2010), English/American painter
Max Slevogt (1868–1932), German painter and illustrator
Władysław Ślewiński (1854–1918), Polish/French painter
Pieter Cornelisz van Slingelandt (1640–1691), Dutch painter
Hamilton Sloan (born 1946), Northern Irish painter
John Sloan (1871–1951), American painter and etcher
Arie Smit (1916–2016), Dutch/Indonesian painter
Grace Cossington Smith (1892–1984), Australian painter
Jack Smith (1928–2011), English artist
Leon Polk Smith (1906–1996), American painter
Matthew Smith (1879–1959), English painter
Xanthus Russell Smith (1839–1929), American painter
Franciszek Smuglewicz (1745–1807), Polish/Lithuanian draftsman and painter
Eero Snellman (1890–1951), Finnish painter
Peter Snow (1927–2008), English painter, theater designer and teacher
Sylvia Snowden (born 1942), American painter
Joan Snyder (born 1940), American painter
Sō Shiseki (宋紫石, 1715–1786), Japanese painter
Sōami (相阿弥, died 1525), Japanese painter
Gerard Soest (1600–1681), English portrait painter
Koloman Sokol (1902–2003), Austro-Hungarian (Slovak)/Czechoslovak painter, graphic artist and illustrator
Xul Solar (1887–1963), Argentine painter, sculptor and writer
Josep Rovira Soler, (1900–1998), Spanish (Catalan)/Cuban painter
Anton Solomoukha (born 1945), Soviet/French artist and photographer
Konstantin Somov (1869–1939), Russian/French artist
Jens Søndergaard (1895–1957), Danish painter
Song Maojin (宋懋晉, fl. 14th, 15th or 16th c.), Chinese painter
Song Xu (宋旭, born 1525), Chinese painter and Buddhist priest
Rajesh Soni (born 1981), Indian artist and photographer
David G. Sorensen (1937–2011), Canadian artist
Hendrik Martenszoon Sorgh (1610–1670), Dutch painter
Joaquín Sorolla (1863–1923), Spanish painter
John Souch (1593/1594–1645), English portrait painter
Pierre Soulages (1919–2022), French painter, engraver and sculptor
Camille Souter (born 1929), Irish painter
Chaïm Soutine (1894–1944), Russian/French painter
Amadeo de Souza Cardoso (1887–1918), Portuguese painter
Isaac Soyer (1902–1981), American painter
Moses Soyer (1899–1974), American painter
Raphael Soyer (1899–1987), American painter, draftsman and print-maker
Austin Osman Spare (1886–1956), English draftsman, painter and oculist
Stanley Spencer (1891–1959), English painter
Nancy Spero (1926–2009), American visual artist
Carl Spitzweg (1808–1885), German painter
Sebastian Spreng (born 1956), Argentine/American visual artist and writer on music
Ignatius Sserulyo (born 1937), Ugandan painter
Nicolas de Staël (1914–1955), French painter
Jan Stanisławski (1860–1907), Austro-Hungarian (Polish) painter
Otto Stark (1859–1926), American artist, print-maker and illustrator
Wojciech Korneli Stattler (1800–1875), Polish painter and professor
Christian W. Staudinger (born 1952), German sculptor, painter and poet
Karl Stauffer-Bern (1857–1891), Swiss painter, etcher and sculptor
Henryk Stażewski (1894–1988), Polish painter
Karel Štěch (1908–1982), Czechoslovak painter, graphic designer and illustrator
T. C. Steele (1847–1926), American painter
John Steell (1804–1891), Scottish sculptor
Jan Steen (c. 1626 – 1679), Dutch painter
Hendrik van Steenwijk I (1550–1603), Dutch/German painter
Hendrik van Steenwijk II (1580–1649), Flemish/Dutch painter
Philip Wilson Steer (1860–1942), English painter and art teacher
Joe Stefanelli (born 1921), American painter
Johann Gottfried Steffan (1815–1905), Swiss/German landscape painter
Georges Stein (1818–1890), French painter
Jacob Steinhardt (1887–1968), German/Israeli painter and woodcut artist
Eduard von Steinle (1810–1886), Austrian/German painter
Théophile Steinlen (1859–1923), Swiss/French painter and print-maker
Juan Carlos Stekelman (born 1936), Argentine painter and print-maker
Frank Stella (born 1936), American painter, sculptor and print-maker
Joseph Stella (1877–1946), Italian/American painter
Hedda Sterne (1910–2011), Romanian/American artist
Matej Sternen (1870–1949), Austro-Hungarian (Slovenian)/Yugoslav painter
David Watson Stevenson (1842–1904), Scottish sculptor
Helen Stevenson (fl. 1920–1935), Scottish artist and print-maker
Robert Macaulay Stevenson (1854–1952), Scottish painter
William Grant Stevenson (1849–1919), Scottish sculptor and painter
Andrew Stevovich (born 1948), American painter
Julius LeBlanc Stewart (1855–1919), American/French painter
LeConte Stewart (1891–1990), American artist and Mormon
Knute Stiles (1923-2009), American painter, collagist, art critic, teacher, poet
Clyfford Still (1904–1980), American painter
Tobias Stimmer (1539–1584), Swiss painter and illustrator
Andries Stock, Dutch Baroque painter (1580–1648)
Stan Stokes (living), American painter
Matthias Stom (c. 1600 – c. 1652), Dutch or Flemish/Italian painter
Abraham Storck (1644–1708), Dutch painter and draftsman
Thomas Stothard (1755–1834), English painter, illustrator and engraver
William Stott (1857–1900), English painter
Hendrick van Streeck (1659 – post–1720), Dutch painter of interiors
Juriaen van Streeck (1632–1687), Dutch painter
Arthur Streeton (1867–1943), Australian painter
Bartholomeus Strobel (1591–1650), German/Polish painter
Ancell Stronach (1901–1981), Scottish artist
Joseph Dwight Strong (1853–1899), American artist and photographer
Bernardo Strozzi (1581–1644), Italian painter and engraver
Drew Struzan (born 1947), American artist, illustrator and poster designer
Zofia Stryjenska (1891–1976), Polish painter, illustrator and stage designer
Wladyslaw Strzeminski (1893–1952), Polish painter
Gilbert Stuart (1755–1828), American painter
George Stubbs (1724–1806), English painter
Franz Stuck (1863–1928), German painter, sculptor and architect
Walter Stuempfig (1914–1970), American artist and teacher
January Suchodolski (1797–1875), Polish painter and army officer
Serge Sudeikin (1882–1946), Russian artist and set designer
Sudip Roy (born 1960), Indian artist
Alberto Sughi (born 1928), Italian painter
Sugimura Jihei (杉村治平, fl. 1681–1703), Japanese ukiyo-e print-maker
Yasushi Sugiyama (杉山寧, 1909–1993), Japanese nihonga painter
William Holmes Sullivan (1836–1908), English history painter
Altoon Sultan (born 1948), American painter in egg tempera
Sava Šumanović (1896–1942), Yugoslav (Serbian) painter
Kelly Sueda (born 1972), American painter
Sun Junze (孙君泽, fl. 13th or 14th century), Chinese painter
Sun Kehong (孫克弘, 1533–1611), Chinese painter, calligrapher and poet
Sun Long (孫隆, fl. 14th century), Chinese painter
Victor Surbek (1885–1975), Swiss painter
Vasily Surikov (1848–1916), Russian painter
Alan Sutherland (born 1931), Scottish painter
David Macbeth Sutherland (1883–1973), Scottish artist and Director of Gray's School of Art
George B. Sutherland (fl. mid–20th century), American painter and teacher
Graham Sutherland (1903–1980), English painter and print-maker
Carol Sutton (born 1945), American painter
Linda Sutton (born 1947), English painter
Marc-Aurèle de Foy Suzor-Coté (1869–1937), Canadian painter and sculptor
Suzuki Harunobu (鈴木春信, 1724–1770), Japanese ukiyo-e woodblock print-maker
Max Švabinský (1873–1962), Austro-Hungarian (Czech)/Czechoslovak painter, draftsman and academy professor
Max Walter Svanberg (1912–1994), Swedish painter, illustrator and designer
Eva Švankmajerová (1940–2005), Czechoslovak/Czech artist
Svend Rasmussen Svendsen (1864–1945), Norwegian/American artist
Sardar Sobha Singh (1901–1986), Indian painter
Sergei Sviatchenko (born 1952), Soviet (Ukrainian)/Danish collage artist
Herman van Swanevelt (1604–1655), Dutch painter and etcher
Roger Swainston (born 1960), Australian painter, naturalist and zoologist
Barbara Swan (1922–2003), American painter, illustrator, and lithographer
Sigurd Swane (1879–1973), Danish painter and poet
Albert Swinden (1901–1961), American painter
Fedot Sychkov (1870–1958), Russian/Soviet painter
George Gardner Symons (1861/1863 – 1930), American painter
Bertalan Székely (1835–1910), Hungarian painter
Adam Szentpétery (born 1956), Hungarian painter
Józef Szermentowski (1833–1876), Polish painter
István Szőnyi (1894–1960), Hungarian painter
Lili Árkayné Sztehló (1897–1959), Hungarian painter and stained-glass decorator
References
References can be found under each entry.
S |
David Lanier "Hot Dog" Hollis (born July 4, 1965) is a former American football defensive back who played three seasons, for the Seattle Seahawks and Kansas City Chiefs. He also played in the Canadian Football League for the Las Vegas Posse.
References
1965 births
Seattle Seahawks players
Kansas City Chiefs players
Las Vegas Posse players
American football defensive backs
UNLV Rebels football players
Players of American football from Los Angeles
People from Harbor City, Los Angeles
Living people |
The 2008–09 season of the female football Superliga Femenina started on 7 September 2008 and finished on 10 May 2009.
Rayo Vallecano won the league for the first time in its history.
Teams
CFF Puebla merged to Extremadura Femenino CF and was relocated to Almendralejo.
League table
Results
References
External links
Season on soccerway.com
2008-09
Spa
1
women |
Peter Rupert William Willsman (born February 1944) is a British political activist who was a member of the Labour Party's National Executive Committee and the secretary of the Campaign for Labour Party Democracy.
He was suspended from the Labour Party and the NEC in May 2019, pending investigation, after publicity over making antisemitic comments, and then expelled in November 2022.
Early life and career
Willsman was born in Andover in 1944.
He worked for the National Union of Public Employees as a researcher.
Political activism
As a delegate representing Canterbury's constituency party to Labour's 1976 conference, Willsman unsuccessfully moved a resolution to make comprehensive education compulsory by 1977, rather than maintaining a system with grammar schools and independent schools.
From the 1970s, Willsman has been a central member of the Campaign for Labour Party Democracy, a left-wing group that campaigns for more power to be given to party members, and is its secretary.
Every year between 1981 and 1994, Willsman was elected onto the Labour Party's Conference Arrangements Committee. He was described as one of the left wing of the party's "key strategists" in 1981, having focused on party constitutional issues rather than ideological issues. In his time on this committee, Willsman had a reputation for his expertise on process.
Having lost his seat on this committee in 1994, he was elected to the party's disciplinary National Constitutional Committee in 1995.
He was elected as an Inner London Education Authority member for Woolwich in 1986 and served until the abolition of the authority in 1990.
Willsman has been a long-term, though intermittent, member of Labour's ruling body, the National Executive Committee (NEC). He was first elected in 1998 on a Grassroots Alliance slate. Having failed to win a seat in 2014, Willsman was elected with Momentum support in 2016, coming sixth in the section representing members. For the 2018 elections to the NEC, Willsman was included on Momentum's slate of promoted candidates due to his role as chair of the Campaign for Labour Party Democracy.
During a meeting in 2016, Willsman declared that he wanted the party to split to "get rid of the Blairites". In 2017, he said some disloyal Labour MPs "deserve to be attacked", though sources present at the meeting said it was clear that he meant the MPs should be criticised, rather than face physical violence.
Antisemitism allegations
In July 2018, Willsman was recorded during an NEC discussion on the party's disciplinary code and antisemitism as saying that he had "never seen" antisemitism in the Labour Party. He claimed that those making the accusations were "Trump fanatics" who were "making up duff information without any evidence at all". He was criticised by The Guardian and some Labour politicians, Marie van der Zyl, president of the Board of Deputies of British Jews, called for Willsman to be expelled and the Jewish Labour Movement made a formal complaint. After Willsman apologised, party chair Jennie Formby warned that a repeat occurrence would result in disciplinary action. Momentum withdrew its support for his candidacy for the NEC, even though voting had commenced, describing his remarks as "deeply insensitive and inappropriate", although he retained the support of Jewish Voice for Labour. He came in ninth place and was re-elected in the expanded section representing members: when other members of the Momentum slate asked him to resign given the late withdrawal of Momentum's endorsement, Willsman declined.
In May 2019, a recording of Willsman emerged from an informal conversation he had had with Israeli-American undercover author Tuvia Tenenbom in January 2019, which Willsman had been unaware was being recorded. Willsman had said "This is off the record. It's almost certain who is behind all this anti-Semitism against Jeremy [Corbyn], almost certainly it's the Israeli embassy." Willsman also said that an open letter on the issue signed by 68 rabbis the previous year was "obviously organised by the Israeli embassy". Willsman's comments were widely condemned, with several members of the NEC and Labour MPs calling for his expulsion. Later that month, Willsman was suspended from the party over the allegation, pending investigation. In late 2022, Willsman was expelled from the Labour Party.
References
1944 births
Living people
Comprehensive education
Labour Party (UK) officials |
Lloyd Clarke is a Jamaican ska musician. He had a series of hits in the early 1960s. "Japanese Girl" was featured on Theme Time Radio Hour (season 2).
Singles
"Fool's Day"
"You're a Cheat"
"Love You the Most"
"Japanese Girl" (1963)
"Girl Rush"
"ParapintoBoogie"
References
20th-century Jamaican male singers |
The knob-billed duck (Sarkidiornis melanotos), or African comb duck, is a type of duck found along the tropical/sub-tropical wetlands and waterways of Sub-Saharan Africa and the island of Madagascar, as well as most of South Asia and mainland Indochina.
Most taxonomic authorities classify the knob-billed duck and the comb duck separately. A misidentified species of extinct Mauritian comb duck was initially described from unrecognised remains of the Mauritius sheldgoose (Alopochen mauritiana); this was realised as early as 1897, but the printed case of mistaken identity can still, occasionally, be found in modern-day sources.
Systematics
Uncertainty surrounds the correct systematic placement of this species. Initially, it was placed in the dabbling duck subfamily Anatinae. Later, it was assigned to the "perching ducks", a paraphyletic assemblage of waterfowl most of which are intermediate between dabbling ducks and shelducks. As the "perching ducks" were split up, the knob-billed duck was moved to the Tadorninae or shelduck subfamily.
Analysis of mtDNA sequences of the cytochrome b and NADH dehydrogenase subunit 2 genes, however, suggests that it is a quite basal member of the Anatidae, vindicating the earliest placement. But its closest living relatives cannot be resolved to satisfaction without further study.
Description
This common species is unmistakable. It is one of the largest species of duck. Length can range from , wingspan ranges from and weight from . Adults have a white head freckled with dark spots, and a pure white neck and underparts. The upperparts are glossy blue-black upperparts, with bluish and greenish iridescence especially prominent on the secondaries (lower arm feathers). The male is much larger than the female, and has a large black knob on the bill. Young birds are dull buff below and on the face and neck, with dull brown upperparts, top of the head and eyestripe. Knob-billed ducks are generally larger in size when compared to comb ducks, and flanks are usually lighter (light grey, in females sometimes whitish).
Immature knob-billed ducks look like a large greyish female of the cotton pygmy goose (Nettapus coromandelicus) and may be difficult to tell apart if no other birds are around to compare size and hue. However, knob-billed ducks in immature plumage are rarely seen without adults nearby and thus they are usually easily identified too.
The knob-billed duck is silent except for a low croak when flushed.
Gallery
Ecology
It breeds in still freshwater swamps and lakes in the tropics. It is largely resident, apart from dispersion in the wet season.
This duck feeds on vegetation by grazing or dabbling and to a lesser extent on small fish, invertebrates, and seeds. It can become a problem to rice farmers. Knob-billed ducks often perch in trees. They are typically seen in flocks, small in the wet season, up to 100 in the dry season. Sometimes they separate according to sex.
The knob-billed duck is declining in numbers locally, but due to its wide range it is not considered globally threatened by the IUCN. It is one of the species to which the Agreement on the Conservation of African-Eurasian Migratory Waterbirds applies.
Reproduction
African birds breed during and after the rainy season and may not breed if the rain is scanty. Knob-billed ducks nest mainly in tree holes, also in tall grass.
Males may have two mates at once or up to five in succession. They defend the females and young but not the nest sites.
Females lay 7 to 15 yellowish-white eggs.
References
External links
Species text in The Atlas of Southern African Birds.
Sarkidiornis
Birds of Sub-Saharan Africa
Birds of India
Birds of Southeast Asia
knob-billed duck
Taxa named by Thomas Pennant |
Morton Dauwen Zabel (1901 – April 29, 1964) was an American academic and literary critic. He was the editor-in-chief of Poetry: A Magazine of Verse from 1936 to 1937, taught at the Federal University of Rio de Janeiro from 1944 to 1946 and then the University of Chicago from 1947 to 1964. According to the Poetry Foundation, he was "an important force in mid-20th century American letters."
Early life
Zabel was born in 1901 in Minnesota Lake, Minnesota. He graduated from St. Thomas Military College, where he earned a bachelor's degree. He earned a master's degree from the University of Minnesota and a Ph.D. from the University of Chicago in 1933.
Career
Zabel was an associate editor of Poetry: A Magazine of Verse from 1928 to 1936, and its editor-in-chief from 1936 to 1937. He was the first professor of North American Literature at the Federal University of Rio de Janeiro from 1944 to 1946. He was a professor of English at the University of Chicago from 1947 to 1964.
Zabel authored or edited books about Henry James and Joseph Conrad. He wrote introductions in books by Joseph Conrad, Charles Dickens, Henry James, and he reviewed books and wrote essays for The New Republic, Partisan Review, The Nation, and The Southern Review. According to the Poetry Foundation, he was "an important force in mid-20th century American letters."
Personal life, death and legacy
Zabel never married. He died on April 29, 1964, in Chicago. His funeral was held at the St John's Catholic Church in Minnesota Lake, where he was buried. Zabel is the namesake of the American Academy of Arts and Letters' Morton Dauwen Zabel Award.
Selected works
References
External links
Morton Dauwen Zabel Papers at the Newberry
Guide to the Morton Dauwen Zabel Papers 1901-1964 at the University of Chicago Special Collections Research Center
1901 births
1964 deaths
University of Minnesota alumni
University of Chicago alumni
American magazine editors
Academic staff of the Federal University of Rio de Janeiro
University of Chicago faculty
American literary critics |
A Gainsborough chair (also known as a Martha Washington chair in the United States) is a type of armchair made in England during the eighteenth century. The chair was wide, with a high back, open sides and short arms, and was normally upholstered in leather.
Contemporaries referred to it as a 'French chair', as the most elaborate styles were based on French Rococo chairs from the Louis XV period.
References
Chairs |
The Dawg Pound is the name of the bleacher section behind the east end zone in Cleveland Browns Stadium, the home field of the Cleveland Browns, a National Football League (NFL) franchise based in Cleveland, Ohio.
Formation
According to Hanford Dixon, then a cornerback with the Browns, Dixon himself gave his defensive teammates the name "Dawgs" to inspire them before the 1985 season. The Dawg Pound started during the 1985 training camp at Lakeland Community College in Kirtland. Dixon and fellow cornerback Frank Minnifield started the idea of the pound by using the dog-versus-cat relationship between the quarterback and the defense. "We had the idea of the quarterback being the cat, and the defensive line being the dog," Dixon said. "Whenever the defense would get a regular sack or a coverage sack the defensive linemen and linebackers would bark." This attitude carried into the stands at the training camp, where fans started barking along with the players. Dixon and Minnifield then put up the first "Dawg Pound" banner in front of the bleachers before the first preseason game at old Cleveland Stadium. The bleacher section had the cheapest seats in the stadium, and its fans were already known as the most vocal. They adopted their new identity whole-heartedly, wearing dog noses, dog masks, bone-shaped hats and other outlandish costumes.
Notoriety
Dawg Pound fans quickly developed a reputation for misbehavior as well as vociferousness. Team officials banned the carrying of dog food into the stadium, as bleacher fans would shower the visiting team with Milk-Bones, along with eggs, batteries, and other objects. Dawg Pound fans also consumed hefty amounts of alcohol, even sneaking a keg into the stadium inside a doghouse. Their reputation was such that other teams' rowdy fans would often be compared to them - in 1989, when a Cincinnati Bengals game was halted by the throwing of debris at the visiting Seattle Seahawks, Bengals coach Sam Wyche addressed the crowd, angrily reminding them that, "You don't live in Cleveland, you live in Cincinnati!"
On at least one occasion, Dawg Pound rowdiness affected the outcome of a game. In the fourth quarter of a 1989 game against the hated Denver Broncos, the rain of batteries, rocks, eggs, and other debris coming down from the bleachers was endangering the safety of the players. To move the action away from the east end, referee Tom Dooley had the teams switch sides. That put the wind at the Browns' back. The Browns won on a Matt Bahr field goal that barely cleared the crossbar.
At the final game at Cleveland Stadium in December 1995, fans, including members of the Dawg Pound, ripped the bleachers and seats from the stands, many having brought wrenches, crowbars, and other tools to dislodge the seats. Some fans threw the seats onto the field, while others took them home as souvenirs.
"Here We Go Brownies Here We Go! - Woof! Woof!" is the most common chant heard in the Pound, especially on drives (either offensive or defensive) going towards that end of the field.
The new pound
When Cleveland Browns Stadium was completed in 1999, team officials named the sections in the stadium's east end the Dawg Pound. The new Pound differs from the original in having two decks, but like the Dawg Pound of Cleveland Municipal Stadium, the new stadium's Dawg Pound seats are all bleachers. The Dawg Pound personal seat license was one of the most expensive in the new Stadium.
The new Pound also has official recognition from the team. The team trademarked a Dawg Pound logo, which it uses on select fan memorabilia. This logo was created by NFL Properties and is the only such logo developed for an NFL fan base by the league. It is featured on officially licensed Browns merchandise such as T-shirts, pennants, bumper stickers, etc.
The establishment nature of the new Pound, as well as the more-sterile atmosphere of the new stadium, turned off some veteran fans, especially the old "blue-collar" fan base. This has resulted from what was originally a player and fan movement - the Dawg Pound - having been made "corporate," by the Browns organization, including trademarks, copyrights and an official "Dawg Pound" logo. Also, the more sterile, corporate atmosphere at the new FirstEnergy Stadium (as opposed to the near anarchy at the old stadium in the 1960s-1990s) has been viewed by more traditionalist Browns fans and Dawg Pound season ticket holders as tarnishing the history and traditional passion of the fanbase.
"Bottlegate"
In a crucial late-season 2001 game against the Jacksonville Jaguars, the Browns were driving toward the east end zone for what would have been the winning score. A controversial call on fourth down gave the Jaguars the ball. Browns' receiver Quincy Morgan had caught a pass for a first down on 4th and 1. After Tim Couch spiked the ball on the next play, referee Terry McAulay reviewed Morgan's catch, claiming that the replay officials had buzzed him before Couch spiked the ball. (NFL Rules state that once the next play is completed, the officials cannot under any circumstances review any previous plays.) Upon reviewing the play, McAulay determined that Morgan never had control of the ball, thus the pass was incomplete, and the Jaguars were awarded the ball. Fans in the Dawg Pound began throwing plastic beer bottles (a recently introduced concept from the team's beer sponsor, Miller Lite) and other objects on the players and officials. McAulay declared the game over and sent the teams to the locker rooms. NFL Commissioner Paul Tagliabue then called to override the referee's decision, sending the players back onto the field, where the Jaguars ran out the last seconds under a hail of debris. The incident then would become known as "Bottlegate", and resulted in the immediate ban of plastic beer bottles from future Browns home games.
"GPODAWUND"
In October 2016, a group of Browns fans accidentally swapped two parts of a large three-part banner, causing it to read "This is the GPODAWUND." The hashtag #GPODAWUND was then used by fans as a microcosm of what would be a 1–15 season, which was then followed up by a 0–16 2017 season - only the second such record in NFL history - which the fans "celebrated" with a "perfect season" parade around FirstEnergy Stadium.
Dawg Pound fans
Current ticket prices for the Dawg Pound are $50 per game, and usually require purchase of season tickets. Since construction of the new stadium, the Dawg Pound is populated by more affluent attendees compared to the generally blue collar fan base that made the Municipal Stadium's Dawg Pound famous. Baseball Hall-of-Famer Hank Aaron often attended Browns games at Municipal Stadium and would sit in the Dawg Pound among the fans, albeit incognito.
One of the more famous Dawg Pound season-ticket holders is John Big Dawg Thompson (he had a legal name change to include his nickname), known as the "Canine-in-Chief." Television cameras often showed the offensive-lineman-sized man in his dog mask and No. 98 jersey, although recently he has undergone gastric bypass surgery and lost considerable weight. In 1995, Thompson became an unofficial spokesman for Browns fans fighting the move of the team to Baltimore. He testified before the U.S. House Committee on the Judiciary and appeared on Politically Incorrect with Bill Maher.
Other recognized fans include the Bone Lady (Debra Darnall), Pumpkinhead (Gus Angelone). and The Macho Fan (real name unknown)
See also
Bleacher Bums
Bleacher Creatures
References
Other sources
Grossi, Tony. Tales From the Browns Sideline, n.p.: Sports Publishing LLC, 2004. .
Associated Press (Dec. 17, 2001). "Football Turns Ugly", CBS News.
Nash, Bruce and Allan Zullo. The Football Hall of Shame 2, New York: Pocket Books, 1990. .
External links
Cleveland Browns (official)
U.S. Rep. Dennis Kucinich's tribute to John "Big Dawg" Thompson in the Congressional Record
Cleveland Browns
Culture of Cleveland
Spectators of American football |
Theodor Thomsen (20 March 1904 – 14 May 1982) was a German sailor. He competed for Germany at the 1952 Summer Olympics and won a bronze medal in the Dragon Class with Erich Natusch and Georg Nowka. He also competed for Germany at the 1936 Summer Olympics and for the United Team of Germany at the 1956 Summer Olympics.
References
1904 births
1982 deaths
Sportspeople from Kiel
German male sailors (sport)
Olympic sailors for Germany
Olympic sailors for the United Team of Germany
Olympic bronze medalists for Germany
Olympic medalists in sailing
Medalists at the 1952 Summer Olympics
Sailors at the 1936 Summer Olympics – 6 Metre
Sailors at the 1952 Summer Olympics – Dragon
Sailors at the 1956 Summer Olympics – Dragon |
Aibek Bokoyev (4 January 1982) is a retired Kyrgyzstani footballer, who was a striker. He played for numerous clubs in his native country, including Abdish-Ata Kant and Dordoi-Dynamo Naryn. He was a member and a captain of the Kyrgyzstan national football team.
International Career Stats
Goals for Senior National Team
References
External links
1982 births
Living people
Kyrgyzstani men's footballers
Kyrgyzstan men's international footballers
FC Dordoi Bishkek players
Footballers at the 2010 Asian Games
Men's association football midfielders
Asian Games competitors for Kyrgyzstan |
Shivpuri is a city and a municipality in Shivpuri district located in the central Indian state of Madhya Pradesh. It is in the Gwalior Division of northwest Madhya Pradesh and is the administrative headquarters of Shivpuri District. It is situated at an altitude of above sea level.
The city is a tourist destination in the monsoon season as it has a number of waterfalls like Bhura kho and Tunda Bharkha kho.
Lakes in Shivpuri include Chandpatha jheel, Jadhav Sagar jheel, and other small lakes.
The city is known for its greenery, forests and also as the former summer capital of the Scindia family who at one time ruled the Gwalior. The Indian leader Tatya Tope was hanged in Shivpuri in 1859.. It also refers to a village in Muzaffarnagar.
Geography
Shivpuri is situated at approximately 25.43° north latitude and 77.65° east longitude. By road, Shivpuri is approximately 120 km (74.5 mi) south of Gwalior and 96 km (59.6 mi) west of Jhansi. Shivpuri has an average elevation of approximately .
Climate
Shivpuri goes through a subtropical climate like most of the northern regions of India that features three major seasons mainly, a hot summer, a monsoon season, and a cold winter.
Summer
Summer in Shivpuri arrives in April and lasts till June. During this period Shivpuri remains hot with an average high of 40 °C while the low stays around 26 °C. May is considered as the hottest month of the year when the average high temperature in the city climbs to 43 °C. However, as the season progresses temperature drops slowly.
Monsoon season
Throughout the monsoon, July–September, Shivpuri experiences a much enjoyable temperature with an average high of 34 °C. The minimum, on the other hand, fluctuates between 20 °C -24 °C.
Winter
The winter months remains cool and comfortable enough for the people. The season, from November till March, remains somewhat chilly with the average minimums of 8 °C while the low drops to 2 °C.
History
The first historical mention of Sipri (Shivpuri) was of Emperor Akbar hunting elephants there in 1564.
In the 16th century, Shivpuri, like all of Gwalior, was part the Maratha Empire. The empire weakened at the end of the century, and during the Gardi-ka-wakt, or 'period of unrest', the rajput of Narwar secured the town and district. The Sindhias, under Daulat Scindia, captured the town and district from the ruler of Narwar in 1804, and made the town their summer capital.
See also
Madhav National Park
Dhala crater
Government Medical College, Shivpuri
List of cities in Madhya Pradesh
==References==
Cities in Madhya Pradesh |
Le Divorce is a 2003 romantic comedy-drama film directed by James Ivory from a screenplay by Ruth Prawer Jhabvala and Ivory, based on the 1997 novel of the same name by Diane Johnson.
Plot
Isabel Walker travels to Paris to visit her sister Roxy, a poet who lives with her husband, Frenchman Charles-Henri de Persand, and their young daughter, Gennie. Roxy is pregnant, but her husband has just walked out on her without explanation. Isabel discovers that he has a mistress, a Russian woman named Magda Tellman, whom he intends to marry after securing a divorce from Roxy. Roxy refuses to divorce him.
Roxy is also in possession of a painting of Saint Ursula by Georges de La Tour; the painting belongs to the Walker family, but due to her marriage to Charles-Henri and French community property laws, the ownership is disputed between the two families. The Louvre deems the painting worthless and concludes that it is not a real La Tour. However, the J. Paul Getty Museum takes an interest in the painting and its curator believes that the painting was done by La Tour himself.
Paris-based American author Olivia Pace, a friend of Roxy's, offers Isabel a job. Isabel also meets Yves, Olivia's protégé, and they begin dating. The sisters visit Charles-Henri's family's country home for Sunday brunch, where Isabel meets Charles-Henri's mother Suzanne and her handsome middle-aged brother, Edgar Cosset. Isabel is attracted to the older, wealthy and married Edgar and they begin an affair, although Isabel continues to string Yves along. Edgar begins to send Isabel various gifts, including an expensive red Kelly bag by Hermès, which Isabel carries with her at all times. During a visit to Isabel, Suzanne discovers the Kelly bag, after which she realizes that Edgar is having an affair with Isabel.
Charles-Henri maintains a blasé attitude about his infidelity and insists on a divorce. He also hopes to benefit from the French community property laws in the divorce, especially with regard to the La Tour painting. His mistress Magda is married to a man named Tellman, who begins to stalk and harass Isabel and Roxy, believing the latter to be responsible for his wife's desertion. Charles-Henri's cruelty and insensitivity take their toll on Roxy, and she attempts suicide in late pregnancy. She survives and is supported by Isabel and her lawyer Bertram.
Roxy and Isabel's family arrive from the United States to support the sisters, and to also discuss the divorce proceedings and the ownership of the La Tour painting. Things are further complicated when Edgar's wife, Amélie, discovers the affair through Suzanne. Following a brunch with both families, Suzanne and Amélie privately inform Isabel's mother about the affair; she later confronts Isabel with this information.
During an outing, Magda and Charles-Henri tease Tellman with their new relationship. Later, they are both murdered by Tellman in a crime of passion, with Charles-Henri's body being found in Roxy's apartment complex. Roxy and Bertram come upon the scene and the stress causes her to go into labor. Tellman then follows Isabel and her family on an outing to the Eiffel Tower, where he corners them and pulls a gun, demanding an opportunity to explain to Roxy why he killed her husband. After some persuasion, the distraught Tellman releases the gun to Isabel, who puts it into the Kelly bag and throws it off the Eiffel Tower.
Edgar, persuaded by his socially conscious family's concern, and tiring of his young lover, casually ends his affair with Isabel over lunch, with the gift of a Hermes scarf. Afterwards, Isabel begins a real relationship with Yves. After Roxy's baby is born, she marries Bertram. The family attends an art auction where the La Tour painting sells to The Getty for 4.5 million Euros. Because its ownership is no longer disputed due to Charles-Henri's death, the money goes to the Walker family, who then go on to establish the "Fondation Sainte Ursule" (The Saint Ursula Foundation).
Cast
Locations
Le Divorce was filmed in Paris at locations including Café de Flore, Tour Eiffel, Musée du Louvre and Salle Gaveau. The Eiffel Tower's elevators, stairways and various levels are seen extensively near the end of the film.
Music
The opening title music was Paul Misraki's "Qu'est-ce qu'on attend pour être heureux", sung by Patrick Bruel and Johnny Hallyday from Bruel's CD "Entre deux". The end title music was Serge Gainsbourg's "L'Anamour", sung by Jane Birkin from her CD "Version Jane".
Release
Reception
Le Divorce was given an initial limited release on August 8, 2003, in 34 theaters, where it grossed $516,834 on its opening weekend. It went into wide release on August 29, 2003, in 701 theaters, where it grossed $1.5M on its opening weekend. The film went on to make $9 million in North America and $3.9M in the rest of the world, for a worldwide total of $12.9M.
Critical response
Roger Ebert of the Chicago Sun-Times gave the film three out of four stars and felt that it did not "work on its intended level, because we don't care enough about the interactions of the enormous cast. But it works in another way, as a sophisticated and knowledgeable portrait of values in collision". In his review for The New York Times, A.O. Scott wrote, "As it is, Le Divorce is tasteful, but almost entirely without flavor. It is tough work to sit through a comedy made by filmmakers with so little sense of timing and no evident sense of humor". Entertainment Weekly gave the film a "C" rating and Owen Gleiberman wrote, "I'm disappointed to report that Hudson and Watts have no chemistry as sisters, perhaps because Watts never seems like the expatriate artiste she's supposed to be playing". In his review for the Village Voice, David Ng wrote, "Indeed, featuring a boatload of intercontinental stars who have little to do, Le Divorce uncannily embodies its privileged bilingual milieu. At worst, it suggests a documentary of its own lavish wrap party". Premiere magazine's Glenn Kenny gave the film three out of four stars and wrote, "the picture is a nice return to form for Ivory and company, as well as a welcome stretch for Kate Hudson, whose luminous talents, I fear, are going to be hidden under bushels of stupid Hollywood romantic comedies for the foreseeable future". In his review for The New York Observer, Andrew Sarris wrote, "The film's greatest achievement, however, is in keeping a dizzying variety of characters at odds with each other without any breach of good manners, and without descending to facile stereotypes and caricatures".
References
External links
2003 films
2003 romantic comedy-drama films
American romantic comedy-drama films
English-language French films
Films about divorce
Films about sisters
Films based on American novels
Films directed by James Ivory
Films set in Paris
Films shot in Paris
Films with screenplays by James Ivory
Films with screenplays by Ruth Prawer Jhabvala
2000s French-language films
French romantic comedy-drama films
Merchant Ivory Productions films
2000s English-language films
2003 multilingual films
American multilingual films
French multilingual films
2000s American films
2000s French films |
Mick Finnegan is a former president of the Workers' Party. He was elected to that position on 17 May 2008 at the party's Annual Conference and retired in 2014.
Finnegan is originally from near Bailieborough, County Cavan, but has spent most of his life in Dublin. He worked for many years in the construction industry in both Great Britain and Ireland and was a shop steward in the Dublin Construction Branch of the then Irish Transport and General Workers Union (now SIPTU), before becoming a full-time branch official.
Finnegan was for many years the Workers' Party director of elections in Dublin West on behalf of then party President Tomás Mac Giolla. He contested the 1981 Irish general election for the party (then known as Sinn Féin The Workers Party) in Dublin West, polling 0.7%, as a second candidate to Mac Giolla who was to be elected in the constituency in the November 1982 general election and the 2007 general election in Dublin Mid-West, polling 0.98%. Finnegan also unsuccessfully contested the 1999 Irish local elections, polling 3.4% of the vote and the 2009 local elections in the Lucan electoral area, polling 4.6% of the vote.
References
Year of birth missing (living people)
Living people
Politicians from County Cavan
Politicians from Dublin (city)
Workers' Party (Ireland) candidates in Dáil elections
People from Bailieborough |
The 2008 Challenge Bell was a tennis tournament played on indoor carpet courts. It was the 16th edition of the Challenge Bell, and was part of the Tier III tournaments of the 2008 WTA Tour. It was held at the PEPS de l'Université Laval in Quebec City, Canada, from October 27 through November 2, 2008.
Entrants
Seeds
1 Rankings are as of October 13, 2008
Other entrants
The following players received wildcards into the singles main draw
Sharon Fichman
Marie-Ève Pelletier
Valérie Tétreault
The following players received entry from the qualifying draw:
Carly Gullickson
Varvara Lepchenko
Rebecca Marino
Maria Mokh
The following player received entry as a lucky loser:
Angela Haynes
Withdrawals
Before the tournament
Flavia Pennetta (personal reasons)
Champions
Singles
Nadia Petrova def. Bethanie Mattek, 4–6, 6–4, 6–1
Doubles
Anna-Lena Grönefeld / Vania King def. Jill Craybas / Tamarine Tanasugarn, 7–6(7–3), 6–4
External links
Official website
Challenge Bell
Tournoi de Québec
Challenge Bell
2000s in Quebec City |
Komarovsky () is a closed rural locality (a settlement) in Orenburg Oblast, Russia. Population:
History
Komarovsky was granted urban-type settlement status in 1994. However, the law on the administrative-territorial division of Orenburg Oblast, passed in July 2007 and currently in effect, no longer provides for such a status, making the settlement classified as rural. Nevertheless, some of the more recent sources, such as, for example, the results of the 2010 Census, continue listing Komarovsky under the urban-type settlement designation.
Administrative and municipal status
Within the framework of administrative divisions, it is incorporated as the closed administrative-territorial formation of Komarovsky—an administrative unit with the status equal to that of the districts. As a municipal division, the closed administrative-territorial formation of Komarovsky is incorporated as Komarovsky Urban Okrug.
References
Notes
Sources
Rural localities in Orenburg Oblast
Closed cities |
Michael Maltman Barry (1842 – 5 April 1909), often known as Maltman Barry, was a Scottish political activist who described himself as a Marxist but stood in elections for the Conservative Party.
Biography
Barry was born in Glasgow and moved to London in 1864 to work as a journalist at The Standard, where he reported on parliamentary and labour matters. He became a friend and supporter of Karl Marx, who impressed him with his opposition to the Liberal Party, and thereafter described himself as a Marxist.
In 1871, Barry was appointed as Provisional Chairman of the International Working Men's Association but, after a year, he was compelled to leave the organisation for being too moderate and labelled a possible spy. Despite this, he continued to be active in radical circles, and became the secretary of the Manhood Suffrage League. He became an outspoken supporter of the Tory campaign to intervene in the Russo-Turkish War of 1877–1878. Much of the group objected to this, and the organisation ceased to function by the end of the year. He launched the National Society for the Resistance of Russian Aggression and the Protection of British Interests in the East. Many of its early meetings led to riots, but Barry continued to campaign against Russia into the 1890s.
This experience led Barry to become a supporter of the Conservative Party, but he also worked with Henry Hyde Champion to call for an independent party of workers. At the 1880 general election, Barry unsuccessfully sought the Conservative nomination in Dundee, where he acclaimed the Tory's support for the Factory Acts and also the party's imperial policy.
The Conservative Central Office gave Barry £340 to pass to H. M. Hyndman of the Social Democratic Federation (SDF) in order to fund two of its candidates in the 1885 general election, in the hope that they would defeat Liberal Party MPs. This "Tory gold" was not successful, and led SDF members, including Ramsay MacDonald and James MacDonald, to set up the rival Socialist Union.
Barry changed the spelling of his name to Michael Maltman Barrie, in order for it to appear more Scottish. He worked with Champion to set up an anti-liberal labour alliance in Aberdeen, and published The Labour Elector newspaper from 1888 to 1890 and 1893 to 1894, supporting the Independent Labour Party and campaigning against Jewish immigration.
At the 1892 general election, he stood unsuccessfully as the Conservative candidate in Banffshire, then Morpeth in 1895 and 1900 and North Aberdeen in 1906.
References
1842 births
1909 deaths
British Marxists
Conservative Party (UK) parliamentary candidates
Members of the International Workingmen's Association
Scottish journalists
Scottish Marxists
Social Democratic Federation |
David Homel (born 1952) is an American-Canadian writer and literary translator. He is most noted as a two-time winner of the Governor General's Award for French to English translation, winning the award at the 1995 Governor General's Awards for Why Must a Black Writer Write About Sex?, his translation of Dany Laferrière's Cette grenade dans la main du jeune nègre est-elle une arme ou un fruit?, and alongside Fred A. Reed at the 2001 Governor General's Awards for Fairy Ring, their translation of Martine Desjardins' Le Cercle de Clara.
Originally from Chicago, Illinois, Homel moved to Canada in 1975, first taking a master's at the University of Toronto before settling in Montreal in 1980. He is married to children's writer Marie-Louise Gay, with whom he has cowritten several children's works.
His debut novel Electrical Storms, published in 1988, was shortlisted for the SmithBooks/Books in Canada First Novel Award in 1989. He is also a two-time winner of the Paragraphe Hugh MacLennan Prize for Fiction at the Quebec Writers' Federation Awards, winning in 2003 for The Speaking Cure and in 2019 for The Teardown.
He has been nominated for the Governor General's Award for translation on eight other occasions, for his translations of Laferrière's How to Make Love to a Negro Without Getting Tired (Comment faire l'amour avec un nègre sans se fatiguer) in 1988, An Aroma of Coffee (L'Odeur du café) in 1994 and A Drifting Year (Chronique de la dérive douce) in 1997, Yves Beauchemin's The Second Fiddle (Le Second violon) in 1998, Philippe Poloni's Olivo Oliva in 1999, Monique Proulx's The Heart Is an Involuntary Muscle (Le Cœur est un muscle involontaire) in 2003 and Wildlives (Champagne) in 2009, and Desjardins' All That Glitters (L'Élu du hasard) in 2005.
Works
Fiction
Electrical Storms - 1988
Rat Palms - 1992
Sonya & Jack - 1995
Get on Top - 1999
The Speaking Cure - 2003
Midway - 2010
The Fledglings - 2014
The Teardown - 2019
A House Without Spirits - 2022
Children's, with Marie-Louise Gay
Travels With My Family - 2006
On the Road Again! - 2008
Summer in the City - 2012
The Traveling Circus - 2015
Travels in Cuba - 2021
Non-fiction
Mapping Literature: The Art and Politics of Literary Translation - 1988
Le monde est un document, with photos by John Max - 2002
Lunging Into the Underbrush: A Life Lived Backwards - 2021
Translation
Talking It Out: The October Crisis from Inside - 1987 (Francis Simard, Pour en finir avec Octobre)
How to Make Love to a Negro - 1988 (Dany Laferrière, Comment faire l'amour avec un nègre sans se fatiguer)
The Invisible Empire - 1990 (Denis Côté, L'invisible puissance)
An Aroma of Coffee - 1993 (Dany Laferrière, L'odeur du café)
Why Must a Black Writer Write About Sex - 1995 (Dany Laferrière, Cette grenade dans la main du jeune nègre est-elle une arme ou un fruit?)
Sandman Blues - 1996 (Stéphane Bourguignon, L'avaleur de sable)
A Drifting Year - 1997 (Dany Laferrière, Chronique de la dérive douce)
The Second Fiddle - 1998 (Yves Beauchemin, Le second violon)
Olivo Oliva - 1999 (Philippe Poloni)
Fairy Rings - 2001 (Martine Desjardins, Le cercle de Clara), with Fred A. Reed
The Heart Is an Involuntary Muscle - 2003 (Monique Proulx,Le cœur est un muscle involontaire), with Fred A. Reed
All That Glitters - 2005 (Martine Desjardins, L'élu du hasard), with Fred A. Reed
The Baldwins - 2006 (Serge Lamothe, Les Baldwin), with Fred A. Reed
References
1952 births
Living people
20th-century American novelists
20th-century American non-fiction writers
20th-century American male writers
21st-century American novelists
21st-century American male writers
20th-century Canadian novelists
20th-century Canadian non-fiction writers
20th-century Canadian male writers
21st-century Canadian novelists
21st-century Canadian male writers
American male novelists
American male non-fiction writers
21st-century American memoirists
American translators
American emigrants to Canada
Canadian male novelists
Canadian non-fiction writers
Canadian translators
21st-century Canadian memoirists
Governor General's Award-winning translators
Writers from Chicago
Writers from Montreal
University of Toronto alumni |
Cibodas is a district of Tangerang City, Banten, Indonesia.
References
Tangerang
Districts of Banten |
The Julian March (Serbo-Croatian and ), also called Julian Venetia (; ; ; ), is an area of southeastern Europe which is currently divided among Croatia, Italy, and Slovenia. The term was coined in 1863 by the Italian linguist Graziadio Isaia Ascoli, a native of the area, to demonstrate that the Austrian Littoral, Veneto, Friuli, and Trentino (then all part of the Austrian Empire) shared a common Italian linguistic identity. Ascoli emphasized the Augustan partition of Roman Italy at the beginning of the Empire, when Venetia et Histria was Regio X (the Tenth Region).
The term was later endorsed by Italian irredentists, who sought to annex regions in which ethnic Italians made up most (or a substantial portion) of the population: the Austrian Littoral, Trentino, Fiume and Dalmatia. The Triple Entente promised the regions to Italy in the dissolution of the Austro-Hungarian Empire in exchange for Italy's joining the Allied Powers in World War I. The secret 1915 Treaty of London promised Italy territories largely inhabited by Italians (such as Trentino) in addition to those largely inhabited by Croats or Slovenes; the territories housed 421,444 Italians, and about 327,000 ethnic Slovenes.
A contemporary Italian autonomous region, bordering on Slovenia, is named Friuli Venezia Giulia ("Friuli and Julian Venetia").
Etymology
The term "Julian March" is a partial translation of the Italian name "Venezia Giulia" (or "Julian Venetia"), coined by the Italian Jewish historical linguist Graziadio Ascoli, who was born in Gorizia. In an 1863 newspaper article, Ascoli focused on a wide geographical area north and east of Venice which was under Austrian rule; he called it Triveneto ("the three Venetian regions"). Ascoli divided Triveneto into three parts:
Euganean Venetia (Venezia Euganea or Venezia propria; Venetia in the strict sense), made up of Italy's Veneto region and most of the territory of Friuli (roughly corresponding to the present Italian provinces of Udine and Pordenone)
Tridentine Venetia (Venezia Tridentina): the present Italian region of Trentino-Alto Adige/Südtirol
Julian Venetia (Venezia Giulia): "Gorizia, Trieste and Istria ... including the land between the Venetia in the strict sense of the term, the Julian Alps, and the sea"
According to this definition, Triveneto overlaps the ancient Roman region of Regio X - Venetia et Histria introduced by Emperor Augustus in his administrative reorganization of Italy at the beginning of the first century AD. Ascoli (who was born in Gorizia) coined his terms for linguistic and cultural reasons, saying that the languages spoken in the three areas were substantially similar. His goal was to stress to the ruling Austrian Empire the region's Latin and Venetian roots and the importance of the Italian linguistic element.
The term "Venezia Giulia" did not catch on immediately, and began to be used widely only in the first decade of the 20th century. It was used in official administrative acts by the Italian government in 1922–1923 and after 1946, when it was included in the name of the new region of Friuli-Venezia Giulia.
History
Early Middle Ages to the Republic of Venice
At the end of the Roman Empire and the beginning of the Migration Period, the area had linguistic boundaries between speakers of Latin (and its dialects) and the Germanic- and Slavic-language speakers who were moving into the region. Germanic tribes first arrived in present-day Austria and its surrounding areas between the fourth and sixth centuries. They were followed by the Slavs, who appeared on the borders of the Byzantine Empire around the sixth century and settled in the Eastern Alps between the sixth and eighth centuries. In Byzantine Dalmatia, on the east shore of the Adriatic Sea, several city-states had limited autonomy. The Slavs retained their languages in the interior, and local Romance languages (followed by Venetian and Italian) continued to be spoken on the coast.
Beginning in the early Middle Ages, two main political powers shaped the region: the Republic of Venice and the Habsburg (the dukes and, later, archdukes of Austria). During the 11th century, Venice began building an overseas empire (Stato da Màr) to establish and protect its commercial routes in the Adriatic and southeastern Mediterranean Seas. Coastal areas of Istria and Dalmazia were key parts of these routes since Pietro II Orseolo, the Doge of Venice, established Venetian rule in the high and middle Adriatic around 1000. The Venetian presence was concentrated on the coast, replacing Byzantine rule and confirming the political and linguistic separation between coast and interior. The Republic of Venice began expanding toward the Italian interior (Stato da Tera) in 1420, acquiring the Patriarchate of Aquileia (which included a portion of modern Friuli—the present-day provinces of Pordenone and Udine—and part of internal Istria).
The Habsburg held the March of Carniola, roughly corresponding to the central Carniolan region of present-day Slovenia (part of their holdings in Inner Austria), since 1335. During the next two centuries, they gained control of the Istrian cities of Pazin and Rijeka-Fiume, the port of Trieste (with Duino), Gradisca and Gorizia (with its county in Friuli).
Republic of Venice to 1918
The region was relatively stable from the 16th century to the 1797 fall of the Republic of Venice, which was marked by the Treaty of Campo Formio between Austria and France. The Habsburgs gained Venetian lands on the Istrian Peninsula and the Quarnero (Kvarner) islands, expanded their holdings in 1813 with Napoleon's defeats and the dissolution of the French Illyrian provinces. Austria gained most of the republic's territories, including the Adriatic coast, Istria and portions of present-day Croatia (such as the city of Karlstadt).
Habsburg rule abolished political borders which had divided the area for almost 1,000 years. The territories were initially assigned to the new Kingdom of Illyria, which became the Austrian Littoral in 1849. This was established as a crown land (Kronland) of the Austrian Empire, consisting of three regions: the Istrian peninsula, Gorizia and Gradisca, and the city of Trieste.
The Italian-Austrian war of 1866, followed by the passage of what was then known as Veneto (the current Veneto and Friuli regions, except for the province of Gorizia) to Italy, did not directly affect the Littoral; however, a small community of Slavic speakers in northeastern Friuli (an area known as Slavia friulana - Beneška Slovenija) became part of the Kingdom of Italy. Otherwise, the Littoral lasted until the end of the Austrian Empire in 1918.
The Italians in Julian March supported the Italian Risorgimento: as a consequence, the Austrians saw the Italians as enemies and favored the Slav communities of Julian March. During the meeting of the Council of Ministers of 12 November 1866, Emperor Franz Joseph I of Austria outlined a wide-ranging project aimed at the Germanization or Slavization of the areas of the empire with an Italian presence:
Istrian Italians were more than 50% of the total population of Istria for centuries, while making up about a third of the population in 1900.
Kingdom of Italy (1918–1943)
The Kingdom of Italy annexed the region after World War I according to the Treaty of London and later Treaty of Rapallo, comprising most of the former Austrian Littoral (Gorizia and Gradisca, Trieste and Istria), south-western portions of the former Duchy of Carniola, and the current Italian municipalities of Tarvisio, Pontebba and Malborghetto Valbruna which had been Carinthian (aside from Fusine in Valromana in eastern Tarvisio, which had been part of Carniola). The annexed areas included many partially or fully Slovene or Croat areas. The island of Krk and the municipality of Kastav, which had formerly been part of the Austrian Littoral, became part of the Kingdom of Serbs, Croats and Slovenes (renamed the Kingdom of Yugoslavia in 1929).
Rijeka-Fiume, which had enjoyed special status within the Lands of the Crown of Saint Stephen (the Hungarian part of Austria-Hungary), became an independent city-state in the Treaty of Rapallo: the Free State of Fiume. It was abolished following the 1924 Treaty of Rome and divided between Italy and the Kingdom of Serbs, Croats and Slovenes.
The new provinces of Gorizia (which was merged with the Province of Udine between 1924 and 1927), Trieste, Pola and Fiume (after 1924) were created. Tarvisio, Pontebba, Malborghetto Valbruna, and the westernmost part of the former Littoral around Cervignano del Friuli remained part of Udine (and so Euganean Venetia) after 1927.
Italians lived primarily in cities and along the coast, and Slavs inhabited the interior. Fascist persecution, "centralising, oppressive and dedicated to the forcible Italianisation of the minorities", caused the emigration of about 105,000 Slovenes and Croats from the Julian March—around 70,000 to Yugoslavia and 30,000 to Argentina. Several thousand Dalmatian Italians moved from Yugoslavia to Italy after 1918, many to Istria and Trieste.
In response to the Fascist Italianization of Slovene areas, the militant anti-Fascist organization TIGR emerged in 1927. TIGR co-ordinated Slovene resistance against Fascist Italy until it was dismantled by the secret police in 1941, and some former members joined the Yugoslav Partisans. The Slovene Partisans emerged that year in the occupied Province of Ljubljana, and spread by 1942 to the other Slovene areas which had been annexed by Italy twenty years earlier.
German occupation and resistance (1943–1945)
After the Italian armistice of September 1943, many local uprisings took place. The town of Gorizia was temporarily liberated by partisans, and a liberated zone in the Upper Soča Valley known as the Kobarid Republic lasted from September to November 1943. The German Army began to occupy the region and encountered severe resistance from Yugoslav partisans, particularly in the lower Vipava Valley and the Alps. Most of the lowlands were occupied by the winter of 1943, but Yugoslav resistance remained active throughout the region and withdrew to the mountains.
In the aftermath of the fall 1943 Italian armistice, the first of what became known as the Foibe massacres occurred (primarily in present-day Croatian Istria). The Germans established the Operational Zone of the Adriatic Littoral, officially part of the Italian Social Republic but under de facto German administration, that year. Many areas, (especially north and north-east of Gorizia) were controlled by the partisan resistance, which was also active on the Karst Plateau and interior Istria. The Nazis tried to repress the Yugoslav guerrillas with reprisals against the civilian population; entire villages were burned down, and thousands of people were interned in Nazi concentration camps. However, the Yugoslav resistance took over most of the region by the spring of 1945.
Italian resistance in the operational zone was active in Friuli and weaker in the Julian March, where it was confined to intelligence and underground resistance in the larger towns (especially Trieste and Pula). In May 1945, the Yugoslav Army entered Trieste; over the following days, virtually the entire Julian March was occupied by Yugoslav forces. Retaliation against real (and potential) political opponents occurred, primarily to the Italian population.
Contested region (1945–1954)
The Western allies adopted the term "Julian March" as the name for the territories which were contested between Italy and the People's Federal Republic of Yugoslavia between 1945 and 1947. The Morgan Line was drawn in June 1945, dividing the region into two militarily administered zones. Zone B was under Yugoslav administration and excluded the cities of Pula, Gorizia, Trieste, the Soča Valley and most of the Karst Plateau, which were under joint British-American administration. During this period, many Italians left the Yugoslav-occupied area.
In 1946, U.S. President Harry S. Truman ordered an increase in U.S. troops in their occupation zone (Zone A) and the reinforcement of air forces in northern Italy after Yugoslav forces shot down two U.S. Army transport planes. An agreement on the border was chosen from four proposed solutions at the Paris Peace Conference that year. Yugoslavia acquired the northern part of the region east of Gorizia, most of Istria and the city of Fiume. A Free Territory of Trieste was created, divided into two zones—one under Allied and the other under Yugoslav military administration. Tensions continued, and in 1954 the territory was abolished and divided between Italy (which received the city of Trieste and its surroundings) and Yugoslavia, under the terms of the London Memorandum.
Since 1954
In Slovenia the Julian March is known as the Slovene Littoral, encompassing the regions of Goriška and Slovenian Istria. In Croatia, the traditional name of Istria is used. After the divisions of 1947 and 1954, the term "Julian March" survived in the name of the Friuli-Venezia Giulia region of Italy.
The Treaty of Osimo was signed on 10 November 1975 by the Socialist Federal Republic of Yugoslavia and the Italian Republic in Osimo, Italy, to definitively divide the Free Territory of Trieste between the two states: the port city of Trieste with a narrow coastal strip to the north-west (Zone A) was given to Italy; a portion of the north-western part of the Istrian peninsula (Zone B) was given to Yugoslavia. The treaty became effective on 11 October 1977. For the Italian Government, the treaty was signed by Mariano Rumor, Minister for Foreign Affairs. For Yugoslavia, the treaty was signed by Miloš Minić, the Federal Secretary for Foreign Affairs.
Ethnolinguistic structure
Two major ethnolinguistic clusters were unified in the region. The western portion was inhabited primarily by Italians (Italian, Venetian and Friulian were the three major languages), with a small Istriot-speaking minority. The eastern and northern areas were inhabited by South Slavs (Slovenes and Croats), with small Montenegrin (Peroj) and Serb minorities.
Other ethnic groups included Istro-Romanians in eastern Istria, Carinthian Germans in the Canale Valley and smaller German- and Hungarian-speaking communities in larger urban centres, primarily members of the former Austro-Hungarian elite. This is illustrated by the 1855 ethnographic map of the Austrian Empire compiled by Karl von Czoernig-Czernhausen and issued by the Austrian k. u. k. department of statistics. According to the 1910–1911 Austrian census, the Austrian Littoral (which would be annexed by Italy from 1920 to 1924) had a population of 978,385. Italian was the everyday language (Umgangsprache) of 421,444 people (43.1 percent); 327,230 (33.4 percent) spoke Slovene, and 152,500 (15.6 percent) spoke Croatian. About 30,000 people (3.1 percent) spoke German, 3,000 (0.3 percent) spoke Hungarian, and small clusters of Istro-Romanian and Czech speakers existed. The Friulian, Venetian and Istriot languages were considered Italian; an estimated 60,000 or more "Italian" speakers (about 14 percent) spoke Friulian.
Romance languages
The standard Italian language was common among educated people in Trieste, Gorizia, Istria and Fiume/Rijeka. In Trieste (and to a lesser extent in Istria), Italian was the predominant language in primary education. The Italian-speaking elite dominated the governments of Trieste and Istria under Austro-Hungarian rule, although they were increasingly challenged by Slovene and Croatian political movements. Before 1918, Trieste was the only self-governing Austro-Hungarian unit in which Italian speakers were the majority of the population.
Most of the Romance-speaking population did not speak standard Italian as their native language, but two other closely related Romance languages: Friulian and Venetian. There was no attempt to introduce Venetian into education and administration.
Friulian was spoken in the south-western lowlands of the county of Gorizia and Gradisca (except for the Monfalcone-Grado area, where Venetian was spoken), and in the town of Gorizia. Larger Friulian-speaking centres included Cormons, Cervignano, and Gradisca d'Isonzo. A dialect of Friulian (Tergestine) was spoken in Trieste and Muggia, evolving into a Venetian dialect during the 18th century. According to contemporary estimates, three-quarters of the Italians in the county of Gorizia and Gradisca were native Friulian speakers—one-quarter of the county's population, and seven to eight percent of the population of the Julian March.
Venetian dialects were concentrated in Trieste, Rijeka and Istria, and the Istro-Venetian dialect was the predominant language of the west Istrian coast. In many small west Istrian towns, such as Koper (Capodistria), Piran (Pirano) or Poreč (Parenzo), the Venetian-speaking majority reached 90 percent of the population and 100 percent in Umag (Umago) and Muggia. Venetian was also a strong presence on Istria's Cres-Lošinj archipelago and in the peninsula's eastern and interior towns such as Motovun, Labin, Plomin and, to a lesser extent, Buzet and Pazin. Although Istro-Venetian was strongest in urban areas, clusters of Venetian-speaking peasants also existed. This was especially true for the area around Buje and Grožnjan in north-central Istria, where Venetian spread during the mid-19th century (often in the form of a Venetian-Croat pidgin). In the county of Gorizia and Gradisca, Venetian was spoken in the area around Monfalcone and Ronchi (between the lower Isonzo River and the Karst Plateau) in an area popularly known as Bisiacaria and in the town of Grado. In Trieste the local Venetian dialect (known as Triestine) was widely spoken, although it was the native language of only about half the city's population. In Rijeka-Fiume, a form of Venetian known as Fiumano emerged during the late 18th and early 19th centuries and became the native language of about half the city's population.
In addition to these two large language groups, two smaller Romance communities existed in Istria. In the south-west, on the coastal strip between Pula and Rovinj, the archaic Istriot language was spoken. In some villages of eastern Istria, north of Labin, the Istro-Romanian language was spoken by about 3,000 people.
South Slavic languages
Slovene was spoken in the north-eastern and southern parts of Gorizia and Gradisca (by about 60 percent of the population), in northern Istria and in the Inner Carniolan areas annexed by Italy in 1920 (Postojna, Vipava, Ilirska Bistrica and Idrija). It was also the primary language of one-fourth to one-third of the population of Trieste. Smaller Slovene-speaking communities lived in the Canale Valley (Carinthian Slovenes), in Rijeka and in larger towns outside the Slovene Lands (especially Pula, Monfalcone, Gradisca d'Isonzo and Cormons). Slavia Friulana - Beneška Slovenija, the community living since the eighth century in small towns (such as Resia) in the valleys of the Natisone, Torre and Judrio Rivers in Friuli, has been part of Italy since 1866.
A variety of Slovene dialects were spoken throughout the region. The Slovene linguistic community in the Julian March was divided into as many as 11 dialects (seven larger and four smaller dialects), belonging to three of the seven dialect groups into which Slovene is divided. Most Slovenes were fluent in standard Slovene, with the exception of some northern Istrian villages (where primary education was in Italian and the Slovene national movement penetrated only in the late 19th century) and the Carinthian Slovenes in the Canale Valley, who were Germanised until 1918 and frequently spoke only the local dialect.
Slovene-Italian bilingualism was present only in some north-west Istrian coastal villages and the confined semi-urban areas around Gorizia and Trieste, while the vast majority of Slovene speakers had little (or no) knowledge of Italian; German was the predominant second language of the Slovene rural population.
Croatian was spoken in the central and eastern Istrian peninsula, on the Cres-Lošinj archipelago; it was the second-most-spoken language (after Venetian) in the town of Rijeka. The Kajkavian dialect of Serbo-Croatian was spoken around Buzet in north-central Istria; Čakavian was predominant in all other areas, frequently with strong Kajkavian and Venetian vocabulary influences. Italian-Croatian bilingualism was frequent in western Istria, on the Cres-Lošinj archipelago and in Rijeka, but rare elsewhere.
Linguistic minorities
German was the predominant language in secondary and higher education throughout the region until 1918, and the educated elite were fluent in German. Many Austrian civil servants used German in daily life, especially in larger urban centres. Most of the German speakers would speak Italian, Slovene or Croatian on social and public occasions, depending on their political and ethnic preferences and location. Among the rural population, German was spoken by about 6,000 people in the Canale Valley. In the major urban areas (primarily Trieste and Rijeka), Hungarian, Serbian, Czech and Greek were spoken by smaller communities.
Flags
See also
Austrian Riviera
Battles of the Isonzo
Dalmatia
London Pact
History of Trieste
Venetian Slovenia
Operation Unthinkable
Notes
References
External links
The Problem of Trieste and the Italo-Yugoslav Border by Glenda Sluga
Istituto Giuliano: an Italian association dedicated to the promotion of culture and tradition in the Julian March
Istituto regionale per la storia del movimento di liberazione nel Friuli Venezia Giulia: an Italian association dedicated to the study of the history of resistance war in Friuli and Julian March
Friuli-Venezia Giulia
Geographical, historical and cultural regions of Italy
History of Istria
Italians of Croatia
Modern history of Slovenia
1860s neologisms |
Wallace Lake may refer to:
Wallace Lake (Louisiana), a lake in Louisiana, United States
Tom Wallace Lake, a lake in Kentucky, United States
Lake Wallace, a lake in Victoria, Australia |
Buchy () is a commune in the Seine-Maritime department in the Normandy region in northern France. On 1 January 2017, the former communes of Bosc-Roger-sur-Buchy and Estouteville-Écalles were merged into Buchy.
The inhabitants of the town of Buchy are called Buchois, Buchoises in French.
Geography
A small farming town situated in the Pays de Bray some northeast of Rouen, at the junction of the D7, D41 and the D919 roads. Montérolier-Buchy station has rail connections to Rouen, Lille and Amiens.
Heraldry
Population
Places of interest
The church of Sts. Peter & Paul, dating from the sixteenth century.
An eleventh-century feudal motte.
The seventeenth-century market hall.
See also
Communes of the Seine-Maritime department
References
Communes of Seine-Maritime |
George Lamar Jones (1945 – April 30, 2012) was an American serial killer who killed at least three women in Mississippi and Wisconsin from 1972 to 1997, with his latter murders occurring at the same time as those of Walter E. Ellis, another unrelated serial killer. For his respective crimes, Jones was convicted and sentenced to life imprisonment, remaining behind bars until his death in 2012.
First murder
Little is known of Jones' personal life prior to his first major crime, that being the murder of a woman named Correne Jones on June 10, 1972. He was initially indicted for murder by the circuit court in Greenwood, Mississippi under the alias 'George Lee Jones', which meant that he faced a possible sentence of 20 years imprisonment. In order to avoid this, his attorney presented evidence that Jones suffered from epilepsy from birth and that this affected his behavior at the time of the crime. Because of this, prosecutors offered a plea bargain that allowed him to plead guilty to the lesser charge of manslaughter and be sentenced to five years in prison instead.
After serving out his sentence in full, Jones was released and later moved to Milwaukee, Wisconsin. While living there, he developed an addiction to drugs and amassed numerous convictions for a variety of offenses. During the times he was not incarcerated, Jones took odd jobs as a handyman and would spend his free time in the company of prostitutes.
Murder of Shameika Carter
Arrest and investigation
From 1986 to 2007, a number of young women and teenagers, most of whom were either prostitutes or drug addicts, were raped and strangled to death in Milwaukee. Suspecting that this might be the work of a serial killer, the local police department partnered up with the FBI to seek for potential links between the cases.
One of the cases put under investigation was that of 24-year-old Shameika Carter, a prostitute whose body was found dumped on a pile of garbage on November 19, 1997. Five days later, Jones was identified as the prime suspect in her killing and was arrested for her murder, but police refused to disclose his identity for the first two days as they were investigating him for any potential links to the other murders. Investigators determined that since his release from prison on November 14, Jones had managed to assault two other women in addition to killing Carter, but ruled him out as a suspect in some of the other murders due to the fact he was imprisoned at the time.
When interviewed by investigators, Jones claimed that he first met Carter at the house of a drug dealer where he usually bought crack cocaine. He claimed that she offered to accompany him to a place where they could buy some marijuana, and that the pair later returned to his house to smoke it. Jones then claimed that after refusing to have sex with her, the two started smoking the marijuana mixed in with the cocaine, which made him have a headache. This, coupled with the fact that Carter supposedly mocked him for his apparent inability to get sexually aroused, made him snap and attack her, resulting in Carter being choked to death. Following these confessions, Jones was charged with first-degree murder, and his bail was set at $500,000.
Trial, sentence, and imprisonment
Before he was put on trial, Jones' court-appointed attorney announced that he intended to plead insanity on his client's behalf, citing his client's lifelong epilepsy and its success in the manslaughter case as his reasoning to do so. This was contested by the prosecutors, who pointed out that Jones was intelligent enough to lie when he took a lie detector test. In order to determine whether he was capable of standing trial, he was ordered to undergo a psychiatric evaluation, with one of his examiners being George Palermo, who had also examined Jeffrey Dahmer. After being deemed sane, both Jones and his attorney were prohibited from discussing the case with the media, as Justice Diane Syes claimed that the publicity would make jury selection difficult.
While he awaited charges for Carter's murder, authorities revealed that Jones was considered a possible suspect in three additional murders: the February 1990 murder of Vernell Jeter; the September 1993 murder of Mary Lee Harris and the 1992 murder of Joyce Mims. Unsealed documents showed that Jones acknowledged his sexual encounters with Jeter and Mims, but denied killing them or meeting Harris, whose body was found in a trash container near his house.
In July 1998, Jones pleaded no-contest to the murder charges, claiming that he "[would] not make it through trial" and just wanted to get it over with. As a result, he was subsequently sentenced to life imprisonment without parole. He later appealed the decision on the grounds that the arresting offices had supposedly detained for an unreasonable length of time following his arrest, but this was promptly dismissed by the courts in 2001.
Link to previous murder and death
In March 2010, Jones' DNA was linked to the murder of Harris after a cold case review was conducted by the Milwaukee Police Department. During an interview with the detectives, he recanted his previous claims and admitted that he had invited Harris to smoke crack at his house. While doing this, Jones claimed that he had told her that she talked too fast and should slow down, which angered Harris and quickly escalated into a physical confrontation. After overpowering her, he proceeded to choke her for approximately 15 minutes before letting go. Upon realizing that he had killed her, Jones then panicked, rolled a garbage cart inside his house and dumped her body inside before rolling it back to the nearby apartment building, where it was picked up by sanitation workers not long after. Soon after, he was charged with first-degree reckless homicide in relation to Harris' death.
After being successfully convicted and given another life term, Jones continued to serve his sentences at the Dodge Correctional Institution in Waupun until his death from natural causes on April 30, 2012. For a brief period, his death was erroneously attributed to Walter E. Ellis, who became notorious as "The Milwaukee North Side Strangler" after DNA evidence linked him to the majority of the murders committed from the period of 1986 to 2007. As of July 2022, no further victims have been linked to Jones - the Jeter and Mims homicides were subsequently solved and determined to be unrelated to one another.
See also
Walter E. Ellis
List of serial killers in the United States
References
1945 births
2012 deaths
20th-century American criminals
American male criminals
American people convicted of manslaughter
American people convicted of murder
American prisoners sentenced to life imprisonment
American serial killers
Criminals from Mississippi
People convicted of murder by Wisconsin
People with epilepsy
Prisoners sentenced to life imprisonment by Wisconsin
Prisoners who died in Wisconsin detention
Serial killers from Mississippi
Serial killers from Wisconsin
Serial killers who died in prison custody
Violence against women in the United States |
Louis Victor Allis (born 19 May 1965) is a Dutch computer scientist working in the artificial intelligence (AI) field. In his graduate work, he revealed AI solutions for Connect Four, Qubic, and Gomoku. His dissertation introduced two new game search techniques: proof-number search and dependency-based search. Proof-number search has seen further successful application in computer Go tactical search and many other games.
Career
Allis holds a Ph.D. in Artificial Intelligence from Maastricht University, The Netherlands, and graduated cum laude with a M. Sc. in Computer Science from the Vrije Universiteit, The Netherlands. He has more than 30 publications to his name; the majority of his published work reports on research in search technologies.
He started his career in 1987 as a freelance teacher, course developer and mentor of various AMBI courses for NOVI. Allis has lectured at the Vrije Universiteit in Amsterdam as an assistant professor in artificial intelligence. In 1992, his program Victoria won the 4th Computer Olympiad in the game of Gomoku without losing a single game. His programs had also won first places at the Computer Olympiad in games of Connect Four (1989), Awari (1990, 1991, 1992), and Qubic (1991), thus making him winner of all four early Computer Olympiads.
He co-authored a solution of 4×4×4 Qubic game using his proof-number search technique.
In 1995 he joined Bolesian (a knowledge technology firm in the Netherlands which is a daughter company of Capgemini and specialized in developing advanced systems based on artificial intelligence) as a senior consultant and manager. In 1997 he co-founded Quintiq and was appointed as the company's CEO.
Allis relocated to the Philadelphia office Quintiq in 2010, remaining CEO and a co-owner. Quintiq was acquired by Dassault Systemes in July 2014.
Notes
External links
Allis's home page (archived)
Quintiq company site
Victor Allis at Chess Programming Wiki.
1965 births
Living people
Dutch computer scientists
Dutch chief executives in the technology industry
Artificial intelligence researchers
Go (game) researchers
People from Gemert-Bakel
Maastricht University alumni
Vrije Universiteit Amsterdam alumni |
{{DISPLAYTITLE:C22H28O3}}
The molecular formula C22H28O3 (molar mass: 340.45 g/mol, exact mass: 340.203845 u) may refer to:
Canrenone, an aldosterone antagonist
Norethisterone acetate
Molecular formulas |
Passage (2007) is a historical novel by John David Morley, the story of one man's journey through five centuries of existence in the New World.
Summary
Abducted by conquistadors in the year 1500, the merchant's ward Pablito (alias White Water Bird, alias Paul Zarraté, alias Paul Straight, alias "the World’s Greatest Living Wonder") passes through five books and five ages of man, as he travels from the primordial forests of the Amazon to the Incan empire of Tahuantin-Suyu, to the slave-plantations of colonial Pernambuco, via antebellum New Orleans, to the 1893 Chicago World's Fair, before witnessing the birth of Hollywood and the explosion of an atomic bomb.
Reception
"The testimony of this decelerated man makes for a long, luxuriantly detailed read," Charles Fernyhough noted in The Sunday Telegraph. "This sweeping but pacey 'palimpsest' of a novel wraps up the past of an entire hemisphere in one mesmerising voice," declared Boyd Tonkin in The Independent. “Funny, depressing, optimistic, bleak, fantastic, mundane: John David Morley's remarkable new novel is all of these, often in the space of a single paragraph,” wrote James Porteous in The Herald: "Morley's themes of time, memory, sleep, death, religion, myth and longevity evoke Borges and Marquez and their mixture of magic and mundane. At its best, the book bears comparison with those masters." The critic Frank Kermode hailed Passage as "a remarkable feat of imagination and sheer narrative energy, the apotheosis of the picaro."
In translation
In 2011, Passage was published in Spanish as La Noche Será Larga in a translation by Claudia Conde.
References
External links
Anita Sethi, "Passage by John David Morley", The Independent (September 14, 2008).
2007 British novels
Picaresque novels
British historical novels
British philosophical novels
Novels by John David Morley |
Sigma Chi () International Fraternity is one of the largest North American fraternal literary societies. The fraternity has 244 active undergraduate chapters and 152 alumni chapters across the United States and Canada and has initiated over 350,000 members. The fraternity was founded on June 28, 1855, at Miami University in Oxford, Ohio, by members who split from the Delta Kappa Epsilon fraternity.
Sigma Chi is divided into seven operational entities: the Sigma Chi Fraternity, the Sigma Chi Foundation, the Sigma Chi Canadian Foundation, the Risk Management Foundation, Constantine Capital Inc., the Blue and Gold Travel Services, and the newly organised Sigma Chi Leadership Institute.
Like all fraternities, Sigma Chi has its own colors, insignia, and rituals. According to the fraternity's constitution, "the purpose of this fraternity shall be to cultivate and maintain the high ideals of friendship, justice, and learning upon which Sigma Chi was founded."
History
Founding
Sigma Chi was founded in 1855 by Benjamin Piatt Runkle, Thomas Cowan Bell, William Lewis Lockwood, Isaac M. Jordan, Daniel William Cooper, Franklin Howard Scobey, and James Parks Caldwell as the result of a disagreement over who would be elected Poet in the Erodelphian Literary Society of Miami University in Ohio.
Several members of Miami University's Delta Kappa Epsilon chapter (of which all but one of Sigma Chi's founders were members) were also members of the Erodelphian Literary Society. In the fall of 1854 the literary society was to elect its poet and a member of Delta Kappa Epsilon was nominated for the position. He was supported by five of his brothers, but four others, James Caldwell, Isaac Jordan, Benjamin Runkle, and Franklin Scobey, supported another man who was not a member of the fraternity. Although Thomas Bell and Daniel Cooper were not members of Erodelphian they had aligned themselves with the four dissenting members. The chapter had twelve members total and were evenly divided on the issue. Both sides saw this as a matter of principle and over the next few months their friendships became distanced.
In February 1855 Runkle and his companions planned a dinner for their brothers in an attempt to seal the rift. Whitelaw Reid, one of the other brothers who supported the Delta Kappa Epsilon member as poet, was the only one to arrive. Reid brought a Delta Kappa Epsilon alumnus named Minor Millikin from a nearby town. Reid had told Millikin his side of the dispute and they had arrived to punish the group for not supporting their Delta Kappa Epsilon brother. The leaders of the rebellion, Runkle and Scobey, were to be expelled from the fraternity. The other four would be allowed to stay in the fraternity. Runkle resigned, and after the parent chapter at Yale University was contacted, all six men were formally expelled.
The six men decided to form their own fraternity along with William Lewis Lockwood, a student from New York who had not joined a fraternity. On June 28, 1855, the organization was founded under the name Sigma Phi Fraternity. Lockwood used his business training to help organize the fraternity in its early years. The eventual theft of Sigma Phi's constitution, rituals, seals, and other records from Lockwood's room in Oxford in January 1856 prompted them to change the name of the fraternity to Sigma Chi. It is possible this action could have been forced upon the group as there was already a Sigma Phi Society.
Much of Sigma Chi's heraldry was inspired by the legendary story of the Emperor Constantine from the Battle of Milvian Bridge against Maxentius. The White Cross and the motto "In Hoc Signo Vinces" are examples of the Constantine link.
Founders
Benjamin Piatt Runkle (September 3, 1836 – June 28, 1916) was born in West Liberty, Ohio. Runkle helped design the badge of Sigma Chi based on the story of Constantine and the vision of the Cross. Runkle was known for having a fierce pride and was suspended from Miami University when he fought a member of Beta Theta Pi for sneering at his badge. When the Civil War began Runkle joined the Union Army. He was badly wounded at the Battle of Shiloh and left for dead on the battlefield. Runkle stayed in the army as a career and retired as a major general. After the army he was ordained an Episcopal priest. He was the only founder to serve as Grand Consul. He died on Sigma Chi's 61st birthday in Ohio. He is now buried in Arlington National Cemetery in Arlington, Virginia.
Thomas Cowan Bell (May 14, 1832 – February 3, 1919) was born near Dayton, Ohio. He was twenty-three years old when Sigma Chi was founded, second oldest of the founders. He graduated from Miami University in 1857 and began teaching. In 1861 he enlisted in the Union Army and rose to the rank of lieutenant colonel. After the war he returned to his career in education, serving as the superintendent of schools in Nobles County, Minnesota as well as the principal and president of several preparatory and collegiate institutions in the Western United States. Bell died the day after attending the initiation of Alpha Beta chapter at University of California Berkeley on February 3, 1919. He is buried at the Presidio of San Francisco in San Francisco National Cemetery in California. Section OS, Row 43A, Grave 3.
William Lewis Lockwood (October 31, 1836 – August 17, 1867) was born in New York City. He was the only founder who had not been a member of Delta Kappa Epsilon. He was considered the "businessman" of the founders and managed the first chapter's funds and general operations, becoming the first treasurer of Sigma Chi. After graduating from Miami University in 1858 he moved back to New York and began work as a lawyer. He received serious wounds serving in the Union Army during the Civil War, from which he never fully recovered. He named his son after Franklin Howard Scobey.
Isaac M. Jordan (May 5, 1835 – December 3, 1890) was born in Mifflinburg, Pennsylvania as Isaac Alfred Jordan. His family later moved to Ohio where Jordan met Benjamin Piatt Runkle and became close friends. After graduating from Miami University in 1857 he went on to graduate school, where he graduated in 1862. He then began work as an attorney and was elected to the United States Congress in 1882. He proceeded to change his middle name, Alfred, to just the letter "M" to help distinguish himself from his brother and law partner, Jackson A. Jordan. He died in 1890 after accidentally falling down an elevator shaft while greeting a friend. He is buried in Spring Grove Cemetery in Cincinnati, Ohio.
Daniel William Cooper (September 2, 1830 – December 11, 1920) was born near Fredericktown, Ohio. Cooper was the oldest founder and was elected the first consul of Sigma Chi. After graduating from Miami University in 1857 he became a Presbyterian minister. Cooper's original Sigma Chi badge came into the possession of the Fraternity at the time of his death. It is pinned on every new Grand Consul at their installation. Cooper is buried at the Allegheny Cemetery in Pittsburgh, Pa.
Franklin Howard Scobey (May 27, 1837 – July 22, 1888) was born in Hamilton, Ohio. Scobey was considered The Spirit of Sigma Chi for being friendly with everybody and not just a select group of people. After graduating from Miami University in 1858 he went on to graduate again in 1861 with a law degree. He worked as a journalist in his hometown until 1879 but went on to become a cattleman in Kansas until 1882. Scobey then moved back to Ohio where he took up farming until his death. Never physically robust, Scobey was afflicted with hearing loss in his final years.
James Parks Caldwell (March 27, 1841 – April 5, 1912) was born in Monroe, Ohio. By the age of thirteen Caldwell had completed all academics which could be offered at his local academy. He was then sent to Miami University with advanced credits. Caldwell was just fourteen at the time of the founding making him the youngest of the founders. After Caldwell graduated from Miami University in 1857 he practiced some law in Ohio but moved to Mississippi to begin a career as an educator. When the Civil War broke out he joined the Confederate Army. During the war he was taken prisoner but later, due to the influence of General Benjamin Piatt Runkle, was offered freedom on the condition that he renounce his allegiance to the Confederacy. He rejected this offer and remained loyal to the south. He was later released, again due to the influence of General Runkle. After the war he moved back to Mississippi and was admitted to the bar. He moved to California in 1867 and practiced law. In 1875, he began to travel frequently practicing law and editing newspapers. He died in Biloxi, Mississippi where the latest issues of The Sigma Chi Quarterly were found in his room.
Early years
Constantine chapter
Harry St. John Dixon, a brother from the Psi chapter at the University of Virginia in Charlottesville, Virginia, who fought for the Confederacy, kept a record of all Sigma Chis within his vicinity on the flyleaf of his diary during the Civil War. He began planning a Confederate Army chapter of Sigma Chi with this information. On September 17, 1864 Dixon founded the Constantine chapter of Sigma Chi during the Atlanta campaign with Harry Yerger, a brother from Mississippi who was in Dixon's division. Dixon stated the reasons for which the war-time chapter was created saying,
Dixon and Yerger contacted all brothers listed in the diary who could come to the meeting. They met at night in a deserted log cabin a few miles southwest of Atlanta. Dixon later wrote,
Dixon was elected "Sigma" (president) and Yerger was elected "Chi" (vice president); the chapter also initiated two men. The only badge in the chapter was one Dixon had made from a silver half-dollar.
The last meeting was held New Year's Day 1865. The men at that meeting passed a resolution to pay a "tribute of respect" to the four brothers from the chapter who had died during the war. In May 1939 the Constantine chapter Memorial was erected by Sigma Chi in memory of the Constantine chapter and its members. The memorial is located on U.S. 41 in Clayton County, Georgia.
Purdue case
In 1876, Emerson E. White became president of Purdue University. He required each applicant for admission to sign a pledge "not to join or belong to any so-called Greek society or other college secret society" while attending the school. The Sigma Chi chapter at Purdue, which was already established at the university, sent petitions to the faculty and pleaded their case to the board of trustees, but was unsuccessful in changing the rule.
In the fall of 1881, Thomas P. Hawley applied for admission to the university. Having already been initiated into Sigma Chi, Hawley refused to sign the pledge and was denied admission. Hawley took Purdue to court, but the judge ruled in favor of the faculty's decision. He also ruled, however, that the faculty had no right to deny Hawley from his classes based on the fraternity issue. The case was brought to the Indiana Supreme Court, which reversed the decision on June 21, 1882. This victory for Sigma Chi also allowed other fraternities at Purdue and led to the Purdue president's resignation in 1883.
20th century
During the first half of the 20th century the General Fraternity expanded in many places. In 1899 the Fraternity adopted the flag design created by Henry V. Vinton. In 1901 the Grand Chapter approved the Fraternity's pledge pin. In 1903 at the Grand Chapter in Detroit the Board of Grand Trustees was established. In 1922 the Alpha Beta chapter at University of California, Berkeley held the "Channingway Derby" which led to the creation of the "Sigma Chi Derby Days". Some of the awards created during this time include the Significant Sig Award in 1935 and the Order of Constantine in 1948.
Coming into the beginning of the 20th century, Sigma Chi had installed a total of 74 chapters with 58 still active. Having only established a centralized form of government in 1922, Sigma Chi was installing new chapters at a rate of about one chapter per year. On April 22, 1922, the Beta Omega chapter was installed at the University of Toronto in Toronto, Ontario thus making Sigma Chi an international fraternity.
The Sigma Chi Foundation was created on November 9, 1939, when the Sigma Chi Endowment Foundation was incorporated in Colorado. This educational endowment was first discussed in 1898 by alumni who wanted to assist undergraduates financially so they could finish their undergraduate studies.
The world wars of the 20th century took the lives of 103 Sigs in World War I and 738 in World War II. A great resurgence in undergraduate activity followed World War II due to an increase in chapter memberships. This increase was caused by the men returning from military service who went back to school as well as the usual addition of new brothers.During World War II it became apparent to the General Fraternity officers that a few alumni as well as a few undergraduate chapters believed some of the prerequisites for membership in Sigma Chi were outdated and should be changed or eliminated. This led to the first discussions about membership within the fraternity that continued until early in 1970. Until this time, membership requirements had specified that a potential member must be a "bona fide white male student". After the first discussion in 1948 at the Grand Chapter in Seattle, the committee on Constitutional Amendments tabled the issue pending a further study of the problem to be reported to the 1950 Grand Chapter. The study showed that the issue was "very hot" on 13 campuses with Sigma Chi chapters and only "lukewarm" on a dozen other campuses.
During this time period, the remaining four founders of Sigma Chi (of the original seven) all died; Daniel William Cooper was the last founder to die. Cooper's death led up to the Fraternity gaining one of its most priceless objects, Cooper's Sigma Phi badge. Cooper's body was sent by train to his final resting place in Pittsburgh, and the Beta Theta chapter at the University of Pittsburgh was given the privilege to administer his memorial service. On December 13, 1920, Cooper's body was conveyed to the Beta Theta chapter house where Beta Theta Consul Donald E. Walker removed Cooper's Sigma Phi Badge and replaced it with his own. Beta Theta Pro-Consul, Regis Toomey, sang the hymn "With Sacred Circle Broken" before Cooper was taken to his final resting place.
Nomenclature and insignia
The Badge
The badge of Sigma Chi is a white cross with white and black enamel. Two gold chains connect the two upper arms. Crossed keys are in the upper arm, an eagle's head lies in the left arm, and a scroll lies in its right arm. In the bottom arm lie two clasped hands and seven stars.
The Seal
The seal of Sigma Chi is circular. On the outer edge is "Sigma Chi Fraternity" and at the bottom are the numbers "1855". In the middle lie seven stars and a seven-branched candlestick.
Coat of Arms
The crest of Sigma Chi is a blue Norman Shield with a white cross in its center. On top of the Norman Shield is a scroll and a crest of an eagle's head holding a key. Below it, the fraternity's public motto, "In Hoc Signo Vinces" is placed on a scroll. It can be translated as, "In this sign, thou shalt conquer."
Governance
Chapter officers
Officers in undergraduate chapters mostly have titles derived from Imperial Rome. The top officers of each chapter are known as the Consul (president), Pro Consul (vice-president), Annotator (secretary), Quaestor (treasurer), Magister (pledge trainer), Kustos (sergeant-at-arms), Tribune (communications), Risk Manager, and Historian. Those titles are the primary officers common to all chapters. Chapters also have other positions, such as Social Chairman, Sports Chairman, Scholarship Chairman, House Manager, Recruitment Chairman, etc., plus other positions and titles varying from chapter to chapter.
Alumni chapter positions and duties may also vary from chapter to chapter. Alumni chapters use the more common office titles such as: president, vice-president, secretary, and treasurer.
Grand officers
The international organization uses similar Roman titles, typically with the prefix of "Grand". The Grand Consul is the international president of Sigma Chi. He presides over the Executive Committee and the Grand Chapter.
Grand Chapter
Grand Chapter is the supreme legislative body of Sigma Chi and convenes on odd numbered years. It is composed of one delegate from each active undergraduate chapter and alumni chapter, the Grand Consul and Past Grand Consuls, each being entitled to one vote. The Grand Chapter elects the officers of the Fraternity as well as alter or amend the Constitution, Statutes, and Executive Committee Regulations. It may grant or revoke charters as well as discipline any chapter, officer or member. The most recent Sigma Chi Grand Chapter was held in Toronto, Ontario on June 22–25, 2023.
Grand Council
The Grand Council meets every year when no Grand Chapter is held. The Grand Council consists of the Grand Officers, Past Grand Consuls, members of the Executive Committee, Grand Trustees, Grand Praetors, members of the Leadership Training Board and one undergraduate from each province. It may amend the Statutes or Executive Committee Regulations.
Executive Committee
The Executive Committee meets at least four times a year. The Executive Committee consists of 12 members; Grand Consul, Grand Pro Consul, Grand Quaestor, the immediate Past Grand Consul, a Grand Trustee elected by the Board of Grand Trustees, two Grand Praetors elected by the Praetorial College, one alumnus member-at-large, two undergraduate representatives elected by the undergraduate delegates from each chapter, and the two most recent International Balfour Award winners. The committee regulates the budget and expenditures as well as assign duties to the International Headquarters staff.
Charitable foundations
The Sigma Chi Foundation is a charitable and educational tax-exempt organization, separate and independent from the Fraternity, whose express purpose is to serve as an educational funding resource for the undergraduate and graduate student members of the Sigma Chi Fraternity.
A Board of Governor governs the Foundation. The Foundation's President and CEO is Ashley Woods and the Foundation's offices are based in Evanston, Illinois.
The Sigma Chi Canadian Foundation is the Canadian counterpart of The Sigma Chi Foundation. It serves independently of both the fraternity and the American foundation. It was formed by Canadian Sigma Chi Alumni as a registered charitable foundation to provide a tax-effective way for Canadian Sigma Chi to support the educational pursuits of Canadian undergraduate chapters. The Foundation is guided by a Chair and a Board of Directors of alumni members.
Leadership programs
The Krach Transformational Leaders Workshop (KTLW) is a three-day retreat held annually since 1947. Undergraduate members receive training for specific roles within their chapter. Alumni volunteers are also given mentorship training. The KTLW is named after the 64th Grand Consul of the Fraternity, Keith Krach.
Horizons is a six-day workshop for undergraduate brothers. The program aims to create lifelong values-based leaders.
Mission 365 is a recruitment workshop. Participants are taught how to "increase both the quality and quantity" of potential new members.
The Journey Program is self-improvement training for undergraduate chapters. There are six Journey workshops, each with a specific aim to better one aspect of the chapter.
The Sigma Chi Choices program and The Sigma Chi Crossroads Workshop both aim to combat drug and alcohol abuse and address mental health among members.
Sigma Chi Lifeline is an online resource for those suffering from mental illness. The program aims to prevent suicide among college students by providing information and support for those affected by emotional and mental health issues.
Philanthropy
Derby Days
Derby Days is a series of charity events held by all Sigma Chi chapters. Throughout the course of a week, a participating chapter organizes and hosts a series of events and competitions among their campus' sororities. Money is raised through either donations, or through fundraising-type events. Hosting a Derby Days event is not mandatory for any chapter. A common event held across many campuses is the Derby Run, where brothers must wear derbies throughout the day, while sisters in participating sororities attempt to steal them. According to the International Fraternity's official website, the basic mission of Derby Days is to serve the community. According to archival information at Sigma Chi International Headquarters, the first "Derby Day" event was held in 1916 at the University of California-Berkeley. Then known as the "Channing Way Derby" because of the California-Berkeley chapter's location on Channing Way and College Avenue, the event spread to other chapters who created their own Derby Day. The most money raised by any Sigma Chi chapter was the Iota Psi chapter at Rutgers University in the fall of 2016. The brothers of the Iota Psi chapter raised $300,007 with the help of the eight sororities at the University: Zeta Tau Alpha, Phi Sigma Sigma, Sigma Delta Tau, Phi Mu, Delta Gamma, Gamma Phi Beta, Sigma Kappa, and Alpha Gamma Delta. This money is all donated to the Huntsman Cancer Foundation. $300,007 is the most money raised in a single event by any single Greek Organization in the world.
Merlin Olsen Day of Service
In honor of notable Sigma Chi alumni and NFL Hall of Fame inductee Merlin Olsen, September 15 is recognized by the fraternity as the Merlin Olsen Day of Service. On this day, members of the fraternity are encouraged to volunteer to improve their communities.
Children's Miracle Network Hospitals (CMNH) is Sigma Chi's suggested beneficiary. The organization was introduced to the fraternity by Olsen in 1992. Since then Sigma Chi alumni and undergraduate chapters have raised more than 6.9 million for CMNH. Every chapter has a CMNH affiliate within less than 200 miles, with each chapter donating to the nearest affiliated hospital.
Huntsman Cancer Foundation/Huntsman Cancer Institute
The Huntsman Cancer Institute (HCF/HCI) is Sigma Chi's preferred charitable partner. It was chosen at Sigma Chi's 150th anniversary celebration in 2005. The Huntsman Cancer Institute today is dedicated to researching the causes, treatments, and preventative methods of cancer. The institute was founded in 1995 by Sigma Chi alumnus, and founder of the Huntsman Corporation, Jon M. Huntsman Sr. Huntsman has donated more than 350 million dollars to the institute, and has encouraged his fellow brothers to contribute as well. By 2019, Sigma Chi undergraduate chapters had raised over $12 million to support the Huntsman Cancer Institute and have raised their pledge to an additional $20 million. In calendar year 2021, Sigma Chi undergraduate chapters raised $2,333,232.44. https://sigmachi.org/sigma-chi-contributes-more-than-2-3-million-to-huntsman-cancer-foundation-during-2021-calendar-year/
Awards
Undergraduate awards
Sigma Chi gives out two undergraduate awards, The Peterson Significant Chapter Award, which is given to chapters who show a strong performance in all areas of chapter operations, and The International Balfour Award, which is given each year to one graduating senior who excels in four criteria; scholarship, character, Fraternity service and campus leadership.
Alumni awards
The fraternity also gives out three alumni awards: The Significant Sig Award is given to a member who has excelled greatly in his field of study or occupation. The first seven Significant Sig awards were given to George Ade, Roy Chapman Andrews, John T. McCutcheon, Chase S. Osborn, James Wallington, F. Dudleigh Vernor, and Samuel P. Cowley. The Order of Constantine is awarded to alumni members who have devoted long and distinguished service to the Fraternity. The Semi-Century Sig Award is given to brothers who have been active in the fraternity for 50 years or more.
International Sweetheart
Most undergraduate chapters elect a female associated with the chapter as the chapter sweetheart. At each Grand Chapter, the fraternity chooses a Sweetheart from one chapter to be the International Sweetheart of Sigma Chi for two years. The International Sweetheart Award is presented based on personality, character, campus involvement, Sigma Chi activities, general accomplishments, poise, and grace. Each nominee must be the sweetheart of an undergraduate chapter for the year nominated and a student at the nominating chapter's university. Judy Garland was a Sigma Chi Sweetheart from the Ohio State University chapter and Faye Dunaway was a Sigma Chi Sweetheart from The University of Florida chapter.
Military Service Recognition Pin
The Military Service Recognition Pin recognizes honorably discharged veterans or currently serving members of the armed forces who are in good standing with the Sigma Chi Fraternity. The pin consists of a single Norman-style sword thrust upward with a small Sigma Chi Norman Shield with a cross embossed upon it placed upon the lower end of the blade just above the hilt and is to be worn on the brother's lapel. The Military service pin concept and design was created by Life Loyal Sig Anthony Dauer Theta Beta 1993 and was first presented at the 2007 Grand Chapter.
Publications
The Magazine of Sigma Chi
The Magazine of Sigma Chi is the official quarterly publication for undergraduate and alumni brothers of the Sigma Chi Fraternity. First published in 1881 at Gettysburg College, Theta chapter, as The Sigma Chi, publication eventually moved to Chicago and the name was changed to The Sigma Chi Quarterly. The name was later changed to The Magazine of Sigma Chi
The Norman Shield
The Norman Shield is the reference manual of the Fraternity. It was authorized by the 24th Grand Consul Herbert C. Arms at the 1924 Grand Chapter. It was first compiled in 1929 by Arthur Vos, Jr. and based on the booklet he prepared for the Beta Mu chapter at the University of Colorado at Boulder which Vos indicated was based on the material contained in the 1922 Manual and Directory. It contained biographies of the founders, significant alumni, a history of the Fraternity, the Constitution and Statutes, and other writings relevant to the fraternity.
Chapters
As of 2023, the fraternity has sixteen associate chapters or colonies.
Notable Sigma Chi alumni
Sigma Chi has alumni who are notable in many different industries and fields. In athletics Sigma Chi has 5 MLB all-stars, 6 World Series champions, 7 NFL All-Pro players, 6 Super Bowl champions, 2 NCAA Basketball champions, and 3 Olympic medal holders. Some of these notable Sigs include Mike Ditka, Bob Griese, Drew Brees, Sean Payton, Joe Gordon, Jay Wright, and Eric Fonoimoana. In politics Sigma Chi has had 24 U.S. Representatives, 11 U.S. Senators, 8 United States Governors, 5 Lieutenant governors, and 1 United States President through the honorary membership of Grover Cleveland to the University of Michigan chapter. Among Sigma Chi's notable actors include 9 Emmy Award winners, 5 Screen Actors Guild Award winners, 4 Golden Globe Award winners, and 3 Academy Award winners. These notable alumni include Brad Pitt, John Wayne, Tom Selleck, Brian Dennehy, Woody Harrelson, David Letterman, and Ty Burrell.
Controversies and member misconduct
20th century
In 1965 and 1967 respectively, the Sigma Chi chapters at Stanford University in Stanford, California and Whitman College in Walla Walla, Washington, disaffiliated from the national fraternity organization when they refused to abide by the whites-only membership policy of the national organization. The policy of the national organization was changed in 1971 to eliminate the racial discrimination.
2000s
In 2002, chapters at University of Missouri and University of Kansas were both suspended for four years for a severe hazing incident.
In 2004, a 19-year-old University of Oklahoma freshman was found dead in the Sigma Chi fraternity house. The university suspended its recognition of the Beta Kappa chapter. In 2006 the Beta Kappa chapter of Sigma Chi was reinstated at the University of Oklahoma.
The chapter at San Jose State University in San Jose, California found a member, Gregory Johnson, Jr., hanged in its basement on November 22, 2008. Ruled a suicide at the time, a group of activists in 2020 later publicized their concerns over what they believe to be an incomplete investigation of Johnson's death, citing the possibility of racist motivations.
The chapter at the University of Nebraska in Lincoln was suspended for hazing and alcohol consumption violations in 2009. The hazing pledges endured included taking shots of Tabasco hot sauce and vodka until they vomited, they were ordered to do strenuous exercises while their "big brothers" threw objects at them, and one pledge was randomly chosen and was anally penetrated with a vibrating dildo by a hired female stripper during an initiation party. Eight members were arrested and charged with hazing and providing alcohol to minors.
2010s
In 2012, the chapter at the University of Alabama in Tuscaloosa, Alabama was sued by a former pledge after he was severely beaten by fraternity members at a party that resulted in serious injuries, depression, and severe anxiety. The chapter was also cited for providing alcohol to underage people.
In 2013, the chapter at Auburn University in Auburn, Alabama was suspended by the organization (with the university's support) for hazing of new members in 2005.
The chapter at the University of Dayton in Dayton was suspended for three years in 2013 for damaging a store's property, urinating inside the store and exposing themselves to passersby.
A fraternity member at Westminster College in St. Louis served 120 days in jail for violently beating up one of his fraternity brothers in 2013.
The chapter at the University of Central Florida in Orlando was placed on suspension in 2013 after photos surfaced on social media of pledges being forced to consume alcohol and getting sick from over-consumption. Several other fraternities on campus were also accused of hazing and alcohol abuse with their pledges that same semester which led to the president of the university temporarily banning all Greek Life activities on campus.
Three Sigma Chi members at James Madison University in Harrisonburg, Virginia were found guilty of sexually assaulting a female student and distributing a recording of the incident. The members were banned from the campus after their graduation in 2014.
The chapter at the West Virginia University in Morgantown had six members arrested in 2014 and cited by the Morgantown police department for hazing pledges and facilitating underage drinking. After a party hosted by the fraternity, several members dropped off nineteen pledges, most of whom were intoxicated, at a random location far away from campus without their cellphones and wallets and told them to find their way back to their fraternity house on campus as part of a "team building" exercise.
The University of Dayton in Dayton permanently banned the fraternity in 2014 after a member’s death revealed the chapter had not been abiding by the parameters of its suspension.
The University of Houston suspended its Sigma Chi chapter for hazing in 2015. The university also suspended five students pending investigation, and forwarded its findings to the district attorney. The university has accused the national organization of withholding information about the chapter's activities. The chapter was later closed by the national organization.
Westminster College and the national fraternity jointly suspended that school's chapter in 2015. The suspension was in response to hazing, academic problems, and racist and sexist comments by members on social media.
The chapter at Indiana University of Pennsylvania in Indiana, Pennsylvania was suspended by its national governing board in 2015 after a woman was violently pinned down and raped by a student who was not a member or a pledge of the Fraternity.
A Sigma Chi member at Utah State University in Logan was kicked out the fraternity in 2015 after being charged with two counts of rape and aggravated sexual assault. The attacks are believed to have taken place at the fraternity house.
The chapter at Brown University in Providence, Rhode Island was suspended in 2015 for facilitating sexual misconduct and hosting an unauthorized party with alcohol.
The chapter at Louisiana State University in Baton Rouge was shut down in 2015 for repeatedly hazing pledges and illegal drug use in the fraternity house. Two months before the chapter closure a 21-year-old fraternity member died of a heroin overdose.
The chapter at the University of South Carolina in Columbia was shut down in 2016 for mentally and physically abusing pledges. Sigma Chi was the 5th fraternity at USC to be closed or suspended since fall 2014.
The chapter at the University of Arkansas was suspended in 2016 for repeatedly hazing pledges and violating the fraternity and school's no-hazing policy.
A former pledge at the University of Arizona in Tucson sued his chapter in 2016 after his fraternity brothers blamed him for the nonfatal overdose of a female party attendee.
The chapter at Eastern Illinois University was suspended indefinitely following several allegations of hazing pledges.
The chapter at Rutgers University in New Brunswick, New Jersey was closed in 2017 by the Executive Committee, which cited "continued risk management and other accountability issues". Its members were prohibited in engaging in fraternity business until 2023. Earlier that Fall semester, the eight sororities represented in Rutgers Panhellenic Council issued a joint statement condemning harassment orchestrated by Sigma Chi and banning Sigma Chi from all their activities. There were also allegations that during a mixer with Sigma Delta Tau sorority Sigma Chi had spiked the punch they served with Xanax. While these events took place, the Rutgers chapter was already on Restrictive Probation for "Social Policy Violations, Adherences to Other University Policies and Theft/Damage to Property".
After a student at Lehigh University in Bethlehem, Pennsylvania was cited for underage drinking at a fraternity-organized party and two students were hospitalized for alcohol poisoning with none of the fraternity brothers rendering aid, the Lehigh University chapter was suppressed by the national organization in 2017.
The chapter at Florida Atlantic University in Boca Raton expelled a member in 2017 after he was found out to have embezzled over $18,000 from the chapter funds. The reason the former brother embezzled the funds was to fund his heroin addiction.
In May 2018, the Sigma Chi chapter at Stanford University was suspended from recognition at the university following an allegation that seven students may have been drugged by a non-student while visiting members of the university rowing team at the fraternity house. As of January 2022, the fraternity remained on suspension.
The chapter at the University of Richmond was closed in 2019 by the Executive Committee after a university-led investigation into possibly violating the University’s hazing and student conduct policy, and its members were prohibited from participating in Sigma Chi-led activities. The Grand Consul remarked: "The offenses that the chapter has committed are simply too grievous to allow the culture that exists within the group to perpetuate."
The chapter at Troy University was suspended in 2019 after a parent reported an incident of hazing to the police. The Dean of Students commented on the incident: "If it had not come forward, it would’ve been a lot worse." Seven members were removed from the chapter for the event.
The chapter at Fresno State University was suspended in 2019 due to underage drinking, property damage, noise complaints, and multiple physical assaults that resulted in serious injuries at their fraternity-sponsored party they promoted as "Cinco de Drinko", May 5. After learning of the incident, the university and Sigma Chi national headquarters placed the chapter on interim suspension.
The chapter at the University of Missouri was “indefinitely suspended” in 2019, following a 2018 investigation and suspension for illegal use of alcohol, hazing, and disruption of university activities.
2020s
A former pledge at the University of Texas at Arlington (UT Arlington) sued the fraternity for $1 million in 2020. While pledging the fraternity, he was ordered by fraternity members to over consume alcohol which led to alcohol poisoning. Also he was subject to other hazing activity that often led to humiliation and black outs. National leadership of the fraternity decided to suspend the UT Arlington chapter indefinitely.
The chapter at the University of Wisconsin at Madison (UW) was shut down after multiple alcohol violations in 2020. The chapter has a long history of various types of violations and was one of six fraternities at UW to shut down in recent years.
The chapter at University of Arkansas expelled two brothers in 2020 for mocking the murder of George Floyd.
In July 2021, the chapter at Ohio University was suspended for four years after an investigation determined that it had violated hazing rules. The fraternity also admitted it had provided false information to law enforcement and school officials regarding two hazing-related incidents.
A sexual assault was report to University of Nebraska campus police and on social media in August 2021 as having taken place at Sigma Chi in Lincoln. Sigma Chi announced the chapter was being placed on "self-suspension" and the accused fraternity member ejected. The report came in during ongoing street protests against nearby Phi Gamma Delta, where a sexual assault was reported a week prior.
In January 2022, National Public Radio obtained a partial copy of a police report of a call by then-student Elizabeth Holmes on October 5, 2003, in which she said she had been sexually assaulted in the early hours of that morning at the Sigma Chi fraternity house at Stanford University. Holmes would found the biotechnology start-up company Theranos later that same year, and the alleged sexual assault came to light when she was on trial for fraud in her work at the company in 2021.
See also
List of social fraternities and sororities
Reference
External links
Official Sigma Chi website
1855 establishments in Ohio
Fraternities and sororities in Canada
Miami University
North American Interfraternity Conference
Student organizations established in 1855
Student societies in the United States |
Sinployea tenuicostata was a species of small air-breathing land snail, a terrestrial pulmonate gastropod mollusk in the family Charopidae. This species was endemic to the Cook Islands, but has not been found since 1899 and is believed to be extinct.
References
T
Extinct gastropods
Extinct animals of Oceania
Fauna of the Cook Islands
Molluscs of Oceania
Gastropods described in 1872
Taxonomy articles created by Polbot |
TUR European Airways was a charter airline from Turkey that operated from 1988 until 1994.
History
TUR was set up in 1988 and began operations using two Boeing 727-200 for charter operations mostly from Germany flying German tourists and expatriate Turks to Turkey.
In the beginning things went pretty well due to a booming tourist market in Turkey, so much so that in 1991 a McDonnell Douglas MD-83 was added, followed by a second MD-83 a year later. With the additional aircraft, the charter routes were expanded to include Belgium, Great Britain, France, the Netherlands and other northern European countries. Since no other MD-83 were available to for lease, more B727-200s were acquired.
In 1992 TUR entered the Turkish domestic market with flights from its base in Istanbul to Ankara, İzmir and other domestic destinations. The economic problems due to the Gulf War brought a decline in the tourist market and two B727s were sold and flights reduced. By 1993 the losses had mounted and as a result all scheduled flights were given up to concentrate on the charter business. But as losses continued, operations were suddenly halted in 1994 and the airline was liquidated.
Fleet
4 Boeing 727-230 (all ex-Condor aircraft)
1 Boeing 727-076
1 Boeing 737-2M8
2 McDonnell Douglas MD-83
References
External links
Fleet and code information
Defunct airlines of Turkey
Airlines established in 1988
Airlines disestablished in 1994
Defunct charter airlines of Turkey |
Miles Gerard (born about 1550 at Wigan; executed at Rochester 13 (30?) April, 1590) was an English Roman Catholic priest. He is a Catholic martyr, beatified in 1929.
Life
Descended perhaps from the Gerards of Ince, he was, about 1576, tutor to the children of Squire Edward Tyldesley, at Morleys Hall, near Astley, Lancashire. In 1579 he attended the English College at Douai and Reims. He was ordained 7 April 1583, and then stayed on as professor at the college until 31 August 1589 (O.S.), when he started for England with five companions.
At Dunkirk the sailors refused to take more than two passengers; so the missioners tossed for precedence, and Gerard and Francis Dicconson, the eldest (it seems) and youngest of the party, won. Though bound for London, they were driven out of their course into Dover harbour, where they were examined and arrested on suspicion (24 November, N.S.). A contemporary newsletter says that they were wrecked, and escaped the sea only to fall into the hands of persecutors on shore, but this is not consistent with the official records. These show that the prisoners at first gave feigned names and ambiguous answers, but soon thought it better to confess all.
After torture in London prisons under the notorious Richard Topcliffe, they were condemned as traitors. They were taken to Rochester, where they were hanged and quartered, says Father John Curry, writing shortly afterwards.
References
[1] http://www.otley.co.uk/rcchurch/dickinson.htm
Attribution
1550 births
1590 deaths
English beatified people
16th-century venerated Christians
16th-century English Roman Catholic priests
People from Wigan
One Hundred and Seven Martyrs of England and Wales |
```c
/***
*wcschr.c - search a wchar_t string for a given wchar_t character
*
*
*Purpose:
* defines wcschr() - search a wchar_t string for a wchar_t character
*
*******************************************************************************/
#include <vcruntime_internal.h>
#include <intrin.h>
#define XMM_SIZE sizeof(__m128i)
#define XMM_CHARS (XMM_SIZE / sizeof(wchar_t))
#define PAGE_SIZE ((intptr_t)0x1000)
#define PAGE_OFFSET(p) ((PAGE_SIZE-1) & (intptr_t)(p))
#define XMM_PAGE_SAFE(p) (PAGE_OFFSET(p) <= (PAGE_SIZE - XMM_SIZE))
/***
*wchar_t *wcschr(string, c) - search a string for a wchar_t character
*
*Purpose:
* Searches a wchar_t string for a given wchar_t character,
* which may be the null character L'\0'.
*
*Entry:
* wchar_t *str - wchar_t string to search in
* wchar_t ch - wchar_t character to search for
*
*Exit:
* returns pointer to the first occurrence of c in string
* returns NULL if c does not occur in string
*
*Exceptions:
*
*******************************************************************************/
wchar_t * __cdecl wcschr (
const wchar_t * str,
wchar_t ch
)
{
if (__isa_available < __ISA_AVAILABLE_SSE2)
{
while (*str && *str != ch)
str++;
// If the character is a match return pointer, otherwise
// it must be the terminating zero and return NULL.
return (*str == ch) ? (wchar_t *)str : NULL;
}
else
{
__m128i match, characters, temp;
unsigned mask;
unsigned long offset;
// Build match pattern with target character in every position.
match = _mm_cvtsi32_si128(ch);
match = _mm_shufflelo_epi16(match, 0);
match = _mm_shuffle_epi32(match, 0);
for (;;)
{
// If the next XMMWORD does not overlap a page boundary check
// it for match of character or zero.
if (XMM_PAGE_SAFE(str))
{
// Check for match with either the search or zero character.
// There may be more than one match, but only the first is
// significant.
characters = _mm_loadu_si128((__m128i*)str);
temp = _mm_xor_si128(temp, temp);
temp = _mm_cmpeq_epi16(temp, characters);
characters = _mm_cmpeq_epi16(characters, match);
temp = _mm_or_si128(temp, characters);
mask = _mm_movemask_epi8(temp);
// If one or more matches was found, get the position of
// the first one. If that character is the same as the
// search character return the pointer to it, otherwise
// it must be the terminating zero so return NULL.
if (mask != 0)
{
_BitScanForward(&offset, mask);
str = (wchar_t *)(offset + (intptr_t)str);
return (*str == ch) ? (wchar_t *)str : NULL;
}
// No match found in this XMMWORD so skip to next.
str += XMM_CHARS;
}
else
{
// If it is not safe to check an entire XMMWORD, check
// a single character and try again.
if (*str == ch) return (wchar_t *)str;
if (*str == 0) return NULL;
// No match so skip to next characcter.
++str;
}
}
}
}
``` |
The Council of State Governments (CSG) is a nonpartisan, non-profit organization in the United States that serves all three branches of state government.
Founded in 1933 by Colorado state Sen. Henry W. Toll, CSG is a region-based forum that fosters the exchange of insights and ideas to help state officials shape public policy.
The CSG National Headquarters is located in Lexington, Kentucky, but the council also operates regional offices in Atlanta, Chicago, New York City and Sacramento, California. CSG maintains an office in Washington, D.C. that monitors federal government activities and their impact on state issues and programs.
Other CSG services include policy academies, research briefs, webinars and annual conferences and meetings at the national and regional levels.
The CSG Justice Center, which is based in New York City and has offices across the country, provides strategies to increase public safety and strengthen communities.
CSG national leadership includes a governor, who serves as the national president, and a member of a state legislature, who serves as national chair. CSG regions are chaired by state legislators.
CSG membership includes 56 U.S. states and territories; six Canadian provinces also partner with the council. Annual dues are paid by each state and territory to support the council's operations. In addition, revenue is derived from publication sales, registration fees, corporate grants and contributions, and investment income.
The CSG is considered part of the 'Big Seven', a group of organizations that represent local and state government in the United States.
History
In 1925, Henry Wolcott Toll, then a Colorado state senator, created the American Legislators’ Association, the forerunner to CSG, which provided legislators with information and opportunities to connect. Toll believed interstate cooperation was imperative for states to maintain control over inherent state issues.
CSG—the only national organization that serves all three branches of state government—was created in 1933. "Probably 12 or 15 of us sat around a table in a small room," Toll recalled 25 years later. "The Council of State Governments had never been heard of before that day."
About five years after CSG was conceived, a new building at 1313 East 60th St., in Chicago became the council's central home. In 1967, CSG and the Commonwealth of Kentucky entered into an agreement that provided CSG with a headquarters building in Lexington, Kentucky. The building was dedicated on June 9, 1969. In 1993, the state financed the construction of a second building to facilitate the council's continued growth.
Some CSG services have been offered since the early years. The Book of the States, which provides comprehensive data and analysis about state governments and their operations, was first published in 1935. State Government News, which later became the CSG bimonthly magazine, Capitol Ideas, was first published in 1958.
The Eastern Regional Conference was established in 1937. CSG opened a Washington, D.C. office in 1938. The Midwestern Legislative Conference was established in 1945. Both the Southern Conference—now the Southern Legislative Conference—and the Western Regional Conference—now CSG West—were established in 1947. In 2006, the CSG Justice Center was formed.
The CSG Henry Toll Fellowship program, a leadership development program for state officials, was established in 1986.
Timeline
1925 – The American Legislators' Association was established in Denver, CO
1930 – The headquarters of the American Legislators' Association moved to Chicago, IL
1935 – The Council of State Governments (CSG) was established
1937 – The Eastern Regional Conference (ERC) was established as the eastern regional office of CSG
1938 – CSG opened a Washington D.C. office
1945 – The Midwestern Legislative Conference (now a part of CSG Midwest) is established as the midwestern regional office of CSG
1947 – The Southern Conference (now the Southern Legislative Conference) and the Western Regional Conference (now known as CSG West) are established to support CSG's work in the southern and western regions
1969 – The CSG headquarters were moved to Lexington, KY
1986 – The CSG Henry Toll Fellowship, a leadership development program for state officials was established
2006 – The CSG Justice Center was formed out of the ERC justice program
2015 – CSG rededicates its national headquarters after a $5.5 million renovation to the original headquarters building
2016 – CSG changes address to 1776 Avenue of the States
Regional offices
CSG has 6 offices across the country including 4 regional offices, a federal affairs office in Washington D.C., and the headquarters office in Lexington, KY.
Justice Center
On December 3, 2006, The Council of State Governments' Governing Board voted to transform the Eastern Regional Conference's (CSG/ERC) criminal justice program into a national Justice Center. The Justice Center's Board of Directors includes state legislative leaders, judges, corrections administrators, juvenile justice agency directors, and law enforcement professionals, who together represent a cross-section of the senior-level state officials who shape criminal justice policy across the country. The Justice Center is headquartered in New York City with additional offices in Austin, Seattle, Bethesda, and Washington, D.C.
Affiliate organizations
Affiliate organizations contribute specialized expertise, information, resources and issues to the overall mission of CSG. In turn, CSG offers a mechanism by which affiliates may tap into CSG's products and services, and a forum for bringing issues to a broader, collective state audience.
Publications
Capitol Ideas (bimonthly magazine)
The Current State (weekly e-newsletter)
The Book of the States (published annually since 1935, provides data and analyses about state governments and their operations)
Shared State Legislation or SSL (annual volume that compiles legislation on topics of current importance to states)
Presidents and Chairs
See also
National Association of Counties
National Center for State Courts
National Conference of State Legislatures
National League of Cities
Notes
References
Nonpartisan organizations in the United States
Government-related professional associations in the United States
1933 establishments in the United States
Organizations established in 1933
Organizations based in Lexington, Kentucky
Paradiplomacy |
Asteroid Day (also known as International Asteroid Day) is an annual global event which is held on June 30, the anniversary of the Tunguska event in 1908 when a meteor air burst levelled about of forest in Siberia, Russia.
Asteroid Day was cofounded in 2014 (the year after the 2013 Chelyabinsk meteor air burst) by physicist Stephen Hawking, B612 Foundation president Danica Remy, Apollo 9 astronaut Rusty Schweickart, filmmaker Grigorij Richters, and Brian May (Queen guitarist and astrophysicist). Remy, Schweickart, Richters, and May initiated Asteroid Day in October 2014, which they announced during a press conference. It was launched on December 3, 2014.
In 2016, the United Nations proclaimed Asteroid Day be observed globally on June 30 every year in its resolution. The event aims to raise awareness about asteroids and what can be done to protect the Earth, its families, communities, and future generations from a catastrophic event.
Legacy
On Asteroid Day 2017, minor planet 248750 (discoverer M. Dawson) was officially named Asteroidday by the International Astronomical Union.
Asteroid Day declaration
In 2014, the workgroup of Asteroid Day created a declaration known as the "100X Declaration", which appeals to all scientists and technologists who support the idea of saving the Earth from asteroids. The 100X Declaration was signed by more than 22,000 private citizens, including those who are not specialists.
Although more than 1,000,000 asteroids have the potential to strike the Earth, only about one percent have been discovered. The 100X Declaration calls for increasing the asteroid discovery rate to 100,000 (or 100x) per year within the next 10 years. It is hoped that this will bolster efforts for addressing potential strikes.
The main three goals are:
Employ available technology to detect and track near-earth asteroids that threaten human populations via governments and private and philanthropic organizations.
A rapid hundred-fold acceleration of the discovery and tracking of near-earth asteroids to 100,000 per year within the next ten years.
Global adoption of Asteroid Day, heightening awareness of the asteroid hazard and our efforts to prevent impacts, on June 30 – With the United Nations recognition, this action item has been achieved.
Asteroid Day 2015–2019
According to information on asteroiday.org, there were over 2,000 events in its first five years of the day being announced, across 78 countries. 41 astronauts and cosmonauts participated in activities on the day. The general goal was to raise awareness about the threat posed by asteroid impacts. Institutions such as Institut de Ciències de l'Espai, the Natural History Museum in Vienna, the American Natural History Museum, the California Academy of Sciences, the Science Museum in London, the SETI Institute, the European Space Agency, the UK Space Agency, among others participated in educational activities.
United Nations
In February 2016, Romanian astronaut Dumitru Prunariu and the Association of Space Explorers submitted a proposal to the Scientific and Technical Subcommittee of the United Nations that was accepted by the subcommittee, and in June 2016, the United Nations Committee on the Peaceful Uses of Outer Space included the recommendation in its report. The report of the committee was presented for approval to the United Nations General Assembly's 71st session, which it approved on December 6, 2016.
In its resolution, the United Nations declares "30 June International Asteroid Day to observe each year at the international level the anniversary of the Tunguska impact over Siberia, Russian Federation on 30 June 1908 and to raise public awareness about the asteroid impact hazard."
References
External links
Annual events in the United Kingdom
Annual events in the United States
Recurring events established in 2014
Asteroids
June observances
International observances |
Khari Sharif () is an agricultural area between Mirpur and Jhelum of Azad Kashmir, Pakistan. Broadly speaking, Alaqa-e-Khari (translation in English: Area of Khari) refers to the fertile plains of Khari which exist between the mountains of Mirpur and the river Jhelum. Khari has some 80 small and large villages and one of the villages itself is known as Khari Sharif. It is located at a distance of 8 km from the city of Mirpur, Azad Kashmir and is known for housing the shrines of Sufi saints known as Pir Shah Ghazi Qalandar Damri Wali Sarkar and Mian Muhammad Bakhsh.
The place acts as a great seat of learning for students of Islam. Historically it was a residence of a famous dervish of this region.
According to the 1998 Pakistan Census, the population was 9,632.
See also
Baba Shadi Shaheed
References
External links
Khari Sharif
Populated places in Mirpur District |
This was the first edition of the tournament.
Holger Rune won the title after defeating Nino Serdarušić 6–4, 6–2 in the final.
Seeds
Draw
Finals
Top half
Bottom half
References
External links
Main draw
Qualifying draw
Internazionali di Tennis Città di Verona - 1 |
The Khichdi franchise is a Hindi language franchise of television series and films created by Hats Off Productions and UTV Software Communications, written and directed by Aatish Kapadia. The franchise is one of the earliest on Indian Television to adopt the western model of appearing in seasons and also the first Indian television series to be adapted into a Bollywood film series. The franchise has seen several re-airings on both STAR Plus and its affiliated channels.
Inspired by the first Gujarati Play produced by Hats Off Productions, titled Ladakvaya, the franchise commenced as a weekly sitcom, debuting its first season on 10 September 2002 on STAR Plus. The principal cast consisted of actors Supriya Pathak, Rajeev Mehta, Anang Desai, Vandana Pathak, and Jamnadas Majethia, who also co-produced the series with Kapadia. The sitcom consistently ranked among the top family-oriented shows on the channel till its last episode in July 2004. It was succeeded by a direct continuation called Instant Khichdi, which aired on STAR One.
In 2010, the franchise was rebooted and adapted into a full-length feature film titled Khichdi: The Movie, with most of the principal cast reprising their roles from the television series. The film initially performed below expectations at the Box Office and was declared "Below Average" but it ultimately recovered its costs and yielded decent profits.
In 2018, the series returned to television with a third season as a prime-time weeknight show, featuring the original principal cast and characters with a revamped story-line. This season premiered on STAR Plus on 14 April 2018, concluding its run on 22 June 2018.
The success and positive feedback of the 2010 film after its telecast on television encouraged Kapadia to start working on a sequel which is slated to release on Diwali in 2023.
Format
The television series primarily follows an episodic format, with most plots resolving within one or two episodes. Occasionally, the show delves into subplots that span a few episodes or employs flashbacks to advance the narrative.
The initial episodes of the first season portrayed the trials and tribulations of a joint family and often touched an emotional cord. Subsequently, particularly in the second season, the focus shifted towards situational comedy as the characters started fitting themselves into their eccentricities. Several new characters are introduced during the course of the television series, enriching the ensemble.
With the film adaptation in 2010, the franchise took a new direction and dropped-off most of the recurring characters from the television series, focusing primarily on the principal ones.
Television series
Khichdi (2002–2004)
The series introduces the Parekhs as an eccentric Gujarati joint family living in an old mansion in Mumbai.
The first season focuses on the idiosyncratic members of the family, led by the elderly Tulsidas Parekh who does not permit his family members to sell off their house and separate into nuclear families. Later, the Parekhs move into a much larger house left behind by a deceased aunt of Tulsidas. In the last episode, Parekhs become overnight millionaires when they discover oil in their older property.
Instant Khichdi (2004–2005)
The second season focused on the Parekhs as they try to settle themselves into higher society with their new-found wealth (in the first season). They live on in their own eccentric way, trying to ace the lives of the super-rich.
Khichdi Returns (2018)
The third season presents a rebooted story-line, as Parekhs gets stuck after the builder escapes in between the construction of their apartment and some people threaten them to kill until they do not return the money taken in exchange of apartments.
Films
Khichdi: The Movie (2010)
A film based on the series, titled Khichdi: The Movie, was released on 1 October 2010 starring most of the same principal cast. In the film, Parekhs deal with the murder mystery of their neighbor Chakku Singh.
Khichdi 2: Mission Paanthukistan (2023)
After 13 years since the original film, the second film is finally slated for a Diwali release. It is written and directed by Aatish Kapadia and stars the cast from previous film.
Crossovers
In 2005, the series had a crossover with Sarabhai vs Sarabhai, where Himanshu and Hansa are revealed as distant cousins of Maya Sarabhai. The crossover is titled as Khichdi with Sarabhai, with Part 1 and Part 2 serving as the 25th episodes of Sarabhai vs Sarabhai and Instant Khichdi, respectively.
In 2010, the cast of Khichdi: The Movie made a special appearance in SAB TV's sitcom Taarak Mehta Ka Ooltah Chashmah to promote their film.
Cast and characters
Awards and nominations
Khichdi
Indian Television Academy Awards
Winner
2004: Best Actress-Comedy – Supriya Pathak as Hansa
Indian Telly Awards
Winner
2003: TV Actor in a Comic Role (Female) – Supriya Pathak as Hansa
2004: BEST Actor in a Comic Role (Male) – Rajeev Mehta as Praful
2004: Sitcom Writer of the Year – Aatish Kapadia
Nominated
2003: TV Child Artiste of the Year – Yash Mittal as Jacky
2004: The TV Sitcom / Comedy programme of the Year
2004: Lyricist of the Year – Aatish Kapadia
2004: Music Director of the Year – Uttank Vora
2004: Director of the Year (Sitcom) – Aatish Kapadia
2004: Child Artiste of the Year (Female) – Richa Bhadra as Chakki
2004: Child Artiste of the Year (Male) – Yash Mittal as Jacky
2004: Actor in a Comic Role (Male) – Rajeev Mehta as Praful
2004: Actor in a Comic Role (Male) – Anang Desai as Tulsidas Parekh
2004: Actor in a Comic Role (Female) – Supriya Pathak as Hansa
2004: Actor in a Comic Role (Female) – Vandana Pathak as Jayshree
2004: Ensemble (complete star cast of a programme)
2004: The Weekly Serial of the year
2004: Scriptwriter of the year – Aatish Kapadia
Instant Khichdi
Indian Telly Awards
Winner
2005: Best Actor in a Comic Role ( Female ) – Supriya Pathak as Hansa
2005: Best Child Artiste (Male) – Yash Mittal as Jacky
Nominated
2005: Best Sitcom / Comedy Writer – Aatish Kapadia
2005: Best Actor in a Comic Role (Female) – Vandana Pathak as Jayshree
2005: Best Actor in Comic Role (Male) – Rajeev Mehta as Praful
2005: Best Sitcom/Comedy Programme
Khichdi: The Movie
6th Apsara Film & Television Producers Guild Awards
Nominated:Apsara Award for Best Performance in a Comic Role – Jamnadas Majethia
2011 Zee Cine Awards
Nominated:Zee Cine Award for Best Performance in a Comic Role – Jamnadas Majethia
2011 Filmfare Awards
NominatedBest Actress in a Supporting Role — Supriya Pathak
References
External links
Khichdi officially uploaded Episodes
Official Site on STAR Utsav
Instant Khichdi official site on STAR One
Indian television sitcoms
Films based on television series
Indian comedy films
Hats Off Productions
2010s Hindi-language films |
FTD may refer to:
People
Frederick Thomas Dalton (1855–1927), British caricaturist
Places
Fak Tha District, Uttaradit Province, Thailand
Fatehabad Chandrawatiganj Junction railway station, in Madhya Pradesh, India
Music
Follow That Dream Records, a Sony label for re-issuing Elvis Presley recordings
Follow That Dream (band), a Dutch pop band
Instruments
Fender Telecaster Deluxe, an electric guitar
Fender Tweed Deluxe, a guitar amplifier
Songs
"Festival Te Deum", an 1872 composition by Arthur Sullivan
"From This Day", a 1999 single by American heavy metal band Machine Head
Foolish Thing Desire, a 1992 song off the eponymous Daniel Ash album Foolish Thing Desire
Fixin' to Die, 2011 cover of 1940 song Fixin' To Die Blues, off the eponymous album by G. Love, Fixin' To Die
Albums
Fixin' To Die, 2011 album by G. Love
Foolish Thing Desire, 1992 album by Daniel Ash
From The Depths, 2012 album from British progressive death metal band Karybdis
Medicine
Formal thought disorder
Frontotemporal dementia
Sports
FC Tytan Donetsk, a Ukrainian football team
FK Tekstilac Derventa, a Bosnian football club
Technology
Field test display
Flight training device
Other uses
Failure to deliver
Federal Territory Day in Malaysia
Financial Times Deutschland, a German financial newspaper
Florists' Transworld Delivery, a floral wire service, retailer and wholesaler
Foreign Technology Division, a former division of the United States Air Force
See also |
Browne Sugar is the debut album by Tom Browne. It was released in 1979 on GRP Records and reached number six on the Jazz Albums chart in 1979.
Track listing
"Throw Down" (Tom Browne) – 3:56
"I Never Was a Cowboy" (Dave Grusin) – 4:24
"Herbal Scent" (Marcus Miller) – 5:22
"Brother, Brother" (Marcus Miller) – 5:36
"The Closer I Get to You" (James Mtume, Reggie Lucas) – 4:38
"What's Going On" (Marvin Gaye, Renaldo Benson, Al Cleveland) – 5:13
"Promises for Spring" (Tom Browne) – 4:50
"Antoinette Like" (Bernard Wright) – 3:40
Personnel
Tom Browne - trumpet, flugelhorn
Dave Grusin - Oberheim synthesizer, electric piano, Clavinet, mini-Moog synthesizer, percussion
Bernard Wright - acoustic and electric piano
Rob Mounsey - Oberheim synthesizer
Buddy Williams - drums
Errol "Crusher" Bennett - percussion, congas
Sue Evans - percussion, congas
Ron Dean Miller - guitar
Marcus Miller, Francisco Centeno - bass
Michael Brecker - tenor saxophone
Frank Floyd, Patti Austin, Vivian Cherry, Zachary Sanders - vocals
Charts
References
External links
Tom Browne-Browne Sugar at Discogs
1979 debut albums
Tom Browne (trumpeter) albums
GRP Records albums
Albums produced by Dave Grusin |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.