std
FILE __stdin[1] = { std(__SRD, STDIN_FILENO, __stdin) };
FILE __stdout[1] = { std(__SWR, STDOUT_FILENO, __stdout) };
FILE __stderr[1] = { std(__SWR|__SNBF, STDERR_FILENO, __stderr) };
commandline_setstd(const struct place *p, char *std)
if (!strcmp(std, "krc")) {
complain(NULL, "Standard %s not supported by this preprocessor", std);
#define TEST_UNCHANGED_STD(std, x) TEST_STD_(std, x, ==)
#define TEST_NARROW_STD(std, x) TEST_STD_(std, x, <)
#define TEST_WIDE_STD(std, x) TEST_STD_(std, x, >)
setup_std(FILE *std, int line)
if (freopen(filename, "r+", std) == NULL)
if ((r = fwide(std, 0)) != 0)
return (std);
#define TEST_STD_(std, x, op) \
f = setup_std(std, __LINE__); \
std::vector<Botan::Certificate_Store*> trusted_certificate_authorities(
const std::string &type, const std::string &context)
std::vector<Botan::Certificate_Store*> cs { &m_ca };
void add_certificate_file(const std::string &file) {
using namespace std;
std::vector<uint8_t> src;
std::vector<uint8_t> compressed(100, '\0');
std::vector<uint8_t> decompressed(src.size(), '\0');
std::vector<uint8_t> compressed(
std::vector<uint8_t> decompressed(strlen(zDefaultCorruptionData));
std::vector<uint8_t> src;
std::vector<uint8_t> compressed(100, '\0');
std::vector<uint8_t> decompressed(src.size(), '\0');
std::vector<uint8_t> src;
std::vector<uint8_t> compressed(src.size() * 2 + 1000);
for (std::vector<uint8_t>::size_type i = 0; i < src.size(); ++i) {
std::vector<uint8_t> src;
std::vector<uint8_t> compressed(
std::vector<uint8_t> decompressed(strlen(zFixedCorruptionData));
using namespace std;
using namespace std;
using namespace std;
std::cout << "called into aa " << libname << " libname " << "\n";
std::cout << "called into ab " << libname << " libname " << "\n";
std::cout << "called into ac " << libname << " libname " << "\n";
std::cout << "main\n";
std::cout << "handle1 open libaa failed\n";
std::cout << "handle2 open libab failed\n";
std::cout << "handle1 is " << *libname << "\n";
std::cout << "handle2 is " << *libname << "\n";
std::cout << "main\n";
std::cout << "OK: PATH is set\n";
std::cout << "FAILED: PATH not set\n";
std::cout << "OK: __progname is set\n";
std::cout << "FAILED: __progname not set\n";
std::printf("A");
std::printf("a");
std::printf("B");
std::printf("b");
std::printf("C");
std::printf("c");
std::printf("D");
std::printf("d");
std::printf("E");
std::printf("e");
std::cout << "P";
std::cout << "p";
std::cout << "handle1 open libaa failed\n";
using namespace std;
std::string bar("bar");
std::cout << "Catching..." << std::endl;
throw std::string("foo");
catch (const std::string& ex) {
std::cout << ".";
std %r0, 8(%r1); \
std reg, loc
const struct std_timing *std = &data->data.timings[i];
newmode = drm_mode_std(connector, closure->drm_edid, std);
struct ohci_soft_td *std, *sdone, **p;
std = ohci_hash_find_td(sc, done);
if (std != NULL) {
std->dnext = sdone;
done = letoh32(std->td.td_nexttd);
sdone = std;
DPRINTFN(10,("add TD %p\n", std));
struct ohci_soft_td *std, *sdone, *stdnext;
for (std = sdone; std; std = stdnext) {
xfer = std->xfer;
stdnext = std->dnext;
std, xfer, xfer ? xfer->hcpriv : 0));
len = std->len;
if (std->td.td_cbp != 0)
len -= letoh32(std->td.td_be) -
letoh32(std->td.td_cbp) + 1;
std->flags));
if (std->flags & OHCI_ADD_LEN)
cc = OHCI_TD_GET_CC(letoh32(std->td.td_flags));
int done = (std->flags & OHCI_CALL_DONE);
ohci_free_std(sc, std);
OHCI_TD_GET_CC(letoh32(std->td.td_flags)),
ohci_cc_strs[OHCI_TD_GET_CC(letoh32(std->td.td_flags))]));
for (p = std; p->xfer == xfer; p = n) {
struct ohci_soft_td *std = stat;
err = ohci_alloc_std_chain(sc, len, xfer, std, &stat);
std->td.td_flags &= htole32(~OHCI_TD_TOGGLE_MASK);
std->td.td_flags |= htole32(OHCI_TD_TOGGLE_1);
ohci_hash_add_td(struct ohci_softc *sc, struct ohci_soft_td *std)
int h = HASH(std->physaddr);
LIST_INSERT_HEAD(&sc->sc_hash_tds[h], std, hnext);
struct ohci_soft_td *std;
for (std = LIST_FIRST(&sc->sc_hash_tds[h]);
std != NULL;
std = LIST_NEXT(std, hnext))
if (std->physaddr == a)
return (std);
ohci_dump_tds(struct ohci_soft_td *std)
for (; std; std = std->nexttd)
ohci_dump_td(std);
ohci_dump_td(struct ohci_soft_td *std)
bitmask_snprintf((u_int32_t)letoh32(std->td.td_flags),
std, (u_long)std->physaddr, sbuf,
OHCI_TD_GET_DI(letoh32(std->td.td_flags)),
OHCI_TD_GET_EC(letoh32(std->td.td_flags)),
OHCI_TD_GET_CC(letoh32(std->td.td_flags)),
(u_long)letoh32(std->td.td_cbp),
(u_long)letoh32(std->td.td_nexttd),
(u_long)letoh32(std->td.td_be));
struct ohci_soft_td *std = NULL;
std = ohci_alloc_std(sc);
if (std == NULL)
opipe->tail.td = std;
tdphys = std->physaddr;
if (std != NULL)
ohci_free_std(sc, std);
struct ohci_soft_td *std;
std = ohci_hash_find_td(sc, letoh32(sed->ed.ed_headp));
pipe, std);
if (std)
ohci_dump_td(std);
struct ohci_soft_td *std = NULL;
std = KERNADDR(&dma, offs);
std->physaddr = DMAADDR(&dma, offs);
std->nexttd = sc->sc_freetds;
sc->sc_freetds = std;
std = sc->sc_freetds;
sc->sc_freetds = std->nexttd;
memset(&std->td, 0, sizeof(struct ohci_td));
std->nexttd = NULL;
std->xfer = NULL;
ohci_hash_add_td(sc, std);
return (std);
ohci_free_std(struct ohci_softc *sc, struct ohci_soft_td *std)
LIST_REMOVE(std, hnext);
std->nexttd = sc->sc_freetds;
sc->sc_freetds = std;
ohci_free_std_chain(struct ohci_softc *sc, struct ohci_soft_td *std,
for (; std != stdend; std = p) {
p = std->nexttd;
ohci_free_std(sc, std);
struct uhci_soft_td *std, *lstd;
for (std = ux->stdstart; std != lstd; std = std->link.std) {
status = letoh32(std->td.td_status);
UHCI_TD_GET_MAXLEN(letoh32(std->td.td_token)))
struct uhci_soft_td *std;
std = stds[n];
uhci_dump_td(std);
status = letoh32(std->td.td_status);
for (std = ux->stdstart; std != NULL; std = std->link.std) {
nstatus = letoh32(std->td.td_status);
if (UHCI_TD_GET_PID(letoh32(std->td.td_token)) !=
if (std != NULL)
upipe->nexttoggle = UHCI_TD_GET_DT(letoh32(std->td.td_token));
struct uhci_soft_td *std = NULL;
std = KERNADDR(&dma, offs);
std->physaddr = DMAADDR(&dma, offs);
std->link.std = sc->sc_freetds;
sc->sc_freetds = std;
std = sc->sc_freetds;
sc->sc_freetds = std->link.std;
memset(&std->td, 0, sizeof(struct uhci_td));
return (std);
uhci_free_std(struct uhci_softc *sc, struct uhci_soft_td *std)
if (letoh32(std->td.td_token) == TD_IS_FREE) {
printf("uhci_free_std: freeing free TD %p\n", std);
std->td.td_token = htole32(TD_IS_FREE);
std->link.std = sc->sc_freetds;
sc->sc_freetds = std;
uhci_free_std_chain(struct uhci_softc *sc, struct uhci_soft_td *std,
for (; std != stdend; std = p) {
p = std->link.std;
uhci_free_std(sc, std);
p->link.std = lastp;
struct uhci_soft_td *std;
for (std = ux->stdstart; std != NULL; std = std->link.std)
std->td.td_status &= htole32(~(UHCI_TD_ACTIVE | UHCI_TD_IOC));
dataend->link.std = stat;
setup->link.std = next;
stat->link.std = NULL;
struct uhci_soft_td *std;
for (std = sc->sc_vframes[0].htd, link = 0;
std = std->link.std) {
link = letoh32(std->td.td_link);
uhci_dump_td(std);
sxqh = (struct uhci_soft_qh *)std;
struct uhci_soft_td *std;
std = iso->stds[next];
std->td.td_buffer = htole32(buf);
std->td.td_status = htole32(status);
std->td.td_token &= htole32(~UHCI_TD_MAXLEN_MASK);
std->td.td_token |= htole32(UHCI_TD_SET_MAXLEN(len));
uhci_dump_td(std);
struct uhci_soft_td *std;
std = stds[n];
std->td.td_status &= htole32(~(UHCI_TD_ACTIVE | UHCI_TD_IOC));
len = UHCI_TD_GET_MAXLEN(letoh32(std->td.td_token));
struct uhci_soft_td *std, *vstd;
std = iso->stds[i];
vstd != NULL && vstd->link.std != std;
vstd = vstd->link.std)
printf("uhci_device_isoc_close: %p not found\n", std);
vstd->link = std->link;
vstd->td.td_link = std->td.td_link;
uhci_free_std(sc, std);
struct uhci_soft_td *std, *vstd;
std = uhci_alloc_std(sc);
if (std == 0)
std->td.td_status = htole32(UHCI_TD_IOS); /* iso, inactive */
std->td.td_token = htole32(token);
iso->stds[i] = std;
std = iso->stds[i];
std->link = vstd->link;
std->td.td_link = vstd->td.td_link;
vstd->link.std = std;
vstd->td.td_link = htole32(std->physaddr | UHCI_PTR_TD);
uhci_free_std_chain(sc, ux->stdstart->link.std, ux->stdend);
struct uhci_soft_td *std;
std = uhci_alloc_std(sc);
if (std == NULL)
std->link.std = NULL;
std->td.td_link = htole32(UHCI_PTR_T);
std->td.td_status = htole32(0); /* inactive */
std->td.td_token = htole32(0);
std->td.td_buffer = htole32(0);
lsqh->elink = std;
lsqh->qh.qh_elink = htole32(std->physaddr | UHCI_PTR_TD);
std = uhci_alloc_std(sc);
if (std == NULL || sqh == NULL)
std->link.sqh = sqh;
std->td.td_link = htole32(sqh->physaddr | UHCI_PTR_QH);
std->td.td_status = htole32(UHCI_TD_IOS); /* iso, inactive */
std->td.td_token = htole32(0);
std->td.td_buffer = htole32(0);
sc->sc_vframes[i].htd = std;
sc->sc_vframes[i].etd = std;
sc->sc_pframes[j] = htole32(std->physaddr);
uhci_dump_tds(struct uhci_soft_td *std)
for(td = std; td != NULL; td = td->link.std) {
struct uhci_soft_td *std;
i->std = utvfu_norm_params[sc->sc_normi].norm;
v4l2_std_id std;
v4l2_std_id std;
# define FLEX_STD std::
using std::type_identity_t;
val.*m = std::move(v); \