//----------------------------------------------------------------------------------------------------
// Support for jint Atomic::add(jint inc, volatile jint* dest).
//
// Arguments:
//
// inc - GR_I0 (e.g., +1 or -1)
// dest - GR_I1
//
// Results:
//
// GR_RET - the new value stored in dest
//
//
address generate_atomic_add() {
StubCodeMark mark(this, "StubRoutines", "atomic_add");
const Register inc = GR_I0;
const Register dest = GR_I1;
address start = __ emit_fd();
__ mf();
// increment or decrement
__ cmp4(PR6, PR7, 1, inc, Assembler::equal);
__ fetchadd4(PR6, GR_RET, dest, 1, Assembler::acquire);
__ fetchadd4(PR7, GR_RET, dest, -1, Assembler::acquire);
// GR_RET contains result of the fetch, not the add
__ sxt4(GR_RET, GR_RET);
__ adds(PR6, GR_RET, 1, GR_RET);
__ adds(PR7, GR_RET, -1, GR_RET);
__ ret();
return start;
}
LOCAL void PROC do_mask (char *pathend) {
static struct find_t fi;
adds (pathend, mask);
if (_dos_findfirst (path, findattr, &fi))
return;
do { const char *p;
p = fi.name-1; do p++; while (*p == '.');
if (*p == '\0') continue; /* name == dots */
adds (pathend, fi.name); found++;
{ ATTR attr = attr2str (OLD_ATTR, fi.attrib);
if (*NEW_PART != '\0') {
attr = (attr & attr_keep) | attr_set;
if (_dos_setfileattr (path,
attr2str (NEW_ATTR, attr)
& (ATTR)~_A_SUBDIR)) {
sayerror (E_ACCESS, "access denied", path);
continue;
} } }
say (info, path);
} while (_dos_findnext (&fi) == 0);
}
static void
print_key_times(gnutls_buffer_st * str, gnutls_openpgp_crt_t cert, int idx)
{
time_t tim;
adds(str, _("\tTime stamps:\n"));
if (idx == -1)
tim = gnutls_openpgp_crt_get_creation_time(cert);
else
tim =
gnutls_openpgp_crt_get_subkey_creation_time(cert, idx);
{
char s[42];
size_t max = sizeof(s);
struct tm t;
if (gmtime_r(&tim, &t) == NULL)
addf(str, "error: gmtime_r (%ld)\n",
(unsigned long) tim);
else if (strftime(s, max, "%a %b %d %H:%M:%S UTC %Y", &t)
== 0)
addf(str, "error: strftime (%ld)\n",
(unsigned long) tim);
else
addf(str, _("\t\tCreation: %s\n"), s);
}
if (idx == -1)
tim = gnutls_openpgp_crt_get_expiration_time(cert);
else
tim =
gnutls_openpgp_crt_get_subkey_expiration_time(cert,
idx);
{
char s[42];
size_t max = sizeof(s);
struct tm t;
if (tim == 0) {
adds(str, _("\t\tExpiration: Never\n"));
} else {
if (gmtime_r(&tim, &t) == NULL)
addf(str, "error: gmtime_r (%ld)\n",
(unsigned long) tim);
else if (strftime
(s, max, "%a %b %d %H:%M:%S UTC %Y",
&t) == 0)
addf(str, "error: strftime (%ld)\n",
(unsigned long) tim);
else
addf(str, _("\t\tExpiration: %s\n"), s);
}
}
}
static void
print_key_revoked (gnutls_buffer_st * str, gnutls_openpgp_crt_t cert, int idx)
{
int err;
if (idx < 0)
err = gnutls_openpgp_crt_get_revoked_status (cert);
else
err = gnutls_openpgp_crt_get_subkey_revoked_status (cert, idx);
if (err != 0)
adds (str, _("\tRevoked: True\n"));
else
adds (str, _("\tRevoked: False\n"));
}
LOCAL char *PROC nsplit (char *p) {
char *pend = p; ATTR fattr = ALL_ATTR;
/*--- scan trailing name */
for (;;) {
if (p == path) break;
/*!*/ p--;
if (*p == '.') continue; /* skip trailing dots */
if (*p != '\\' && *p != '/' && *p != ':') {
pend = NULL; /* this is filename */
if (*p == '*' || *p == '?') /* check wildcards */
fattr = useattr;
} else {
p++; break;
} }
/*--- extract name, if present */
{ char *q = p;
if (pend) { /* path="[[<something>]\]{.}" */
if (p < pend) p = pend, *p++ = '\\';
fattr = useattr, q = "*.*"; /* default mask value */
}
findattr = fattr, adds (mask, q);
return p;
} }
void cmd(t_all *g_all, t_sel *sel, t_dis *dis)
{
char buf[4];
while (1)
{
init_control(sel, buf);
if (read(0, buf, 4) == -1)
error(2);
if (ENTER)
send_select(g_all, sel);
else if (ESC)
{
myclear(g_all);
mfree();
}
else if (SPACE)
mselect(sel);
else if (UP || DOWN)
displacement_verti(sel, buf[2]);
else if (RIGHT || LEFT)
displacement_hori(sel, buf[2]);
else if (DEL || BSPACE)
sup_elem(g_all, sel);
else if (SELECT || POS)
adds(g_all, sel, buf[0]);
}
}
void jewelryPurchasing::on_pbAdd_EXCEL_clicked()
{
jewelryPurchasingAddExcel adds(this);
if (adds.exec())
{
updateUIFromDatabase();
}
}
LOCAL void PROC do_path (char *pathend) {
struct find_t fi;
do_mask (pathend); if (recurse == 0) return;
adds (pathend, "*.*");
if (_dos_findfirst (path, DIR_ATTR, &fi))
return;
do { const char *p;
if ((fi.attrib & _A_SUBDIR) == 0) continue;
p = fi.name-1; do p++; while (*p == '.');
if (*p == '\0') continue; /* name == dots */
do_path (adds (adds (pathend, fi.name), "\\"));
} while (_dos_findnext (&fi) == 0);
}
LOCAL void PROC process (const char target[]) {
/* if (strlen(target) > sizeof(path)-5) {
* sayerror (E_TARGET, "too long", target);
* return;
* }
*/ found = 0;
do_path (nsplit (adds (path, target)));
if (found == 0) sayerror (E_TARGET, "no targets", target);
}
static void
print_key_usage(gnutls_buffer_st * str, gnutls_openpgp_crt_t cert,
unsigned int idx)
{
unsigned int key_usage;
int err;
adds(str, _("\t\tKey Usage:\n"));
if (idx == (unsigned int) -1)
err = gnutls_openpgp_crt_get_key_usage(cert, &key_usage);
else
err =
gnutls_openpgp_crt_get_subkey_usage(cert, idx,
&key_usage);
if (err < 0) {
addf(str, _("error: get_key_usage: %s\n"),
gnutls_strerror(err));
return;
}
if (key_usage & GNUTLS_KEY_DIGITAL_SIGNATURE)
adds(str, _("\t\t\tDigital signatures.\n"));
if (key_usage & GNUTLS_KEY_KEY_ENCIPHERMENT)
adds(str, _("\t\t\tCommunications encipherment.\n"));
if (key_usage & GNUTLS_KEY_DATA_ENCIPHERMENT)
adds(str, _("\t\t\tStorage data encipherment.\n"));
if (key_usage & GNUTLS_KEY_KEY_AGREEMENT)
adds(str, _("\t\t\tAuthentication.\n"));
if (key_usage & GNUTLS_KEY_KEY_CERT_SIGN)
adds(str, _("\t\t\tCertificate signing.\n"));
}
/* idx == -1 indicates main key
* otherwise the subkey.
*/
static void
print_key_fingerprint(gnutls_buffer_st * str, gnutls_openpgp_crt_t cert)
{
uint8_t fpr[128];
size_t fpr_size = sizeof(fpr);
int err;
const char *name;
char *p;
unsigned int bits;
err = gnutls_openpgp_crt_get_fingerprint(cert, fpr, &fpr_size);
if (err < 0)
addf(str, "error: get_fingerprint: %s\n",
gnutls_strerror(err));
else {
adds(str, _("\tFingerprint (hex): "));
_gnutls_buffer_hexprint(str, fpr, fpr_size);
addf(str, "\n");
}
err = gnutls_openpgp_crt_get_pk_algorithm(cert, &bits);
if (err < 0)
return;
name = gnutls_pk_get_name(err);
if (name == NULL)
return;
p = _gnutls_key_fingerprint_randomart(fpr, fpr_size, name, bits,
"\t\t");
if (p == NULL)
return;
adds(str, _("\tFingerprint's random art:\n"));
adds(str, p);
adds(str, "\n");
gnutls_free(p);
}
void JobScriptOutput::addf(const char *fmt, ...) {
char buf[8192];
va_list val;
long l;
va_start(val, fmt);
_vsnprintf(buf, sizeof buf, fmt, val);
va_end(val);
buf[sizeof buf-1]=0;
l = strlen(buf);
adds(buf);
}
static void
hexprint (gnutls_buffer_st * str, const char *data, size_t len)
{
size_t j;
if (len == 0)
adds (str, "00");
else
{
for (j = 0; j < len; j++)
addf (str, "%.2x", (unsigned char) data[j]);
}
}
static void
hexdump (gnutls_buffer_st * str, const char *data, size_t len,
const char *spc)
{
size_t j;
if (spc)
adds (str, spc);
for (j = 0; j < len; j++)
{
if (((j + 1) % 16) == 0)
{
addf (str, "%.2x\n", (unsigned char) data[j]);
if (spc && j != (len - 1))
adds (str, spc);
}
else if (j == (len - 1))
addf (str, "%.2x", (unsigned char) data[j]);
else
addf (str, "%.2x:", (unsigned char) data[j]);
}
if ((j % 16) != 0)
adds (str, "\n");
}
bool CharCreationManager::LoadLifeEvents()
{
Result events(db->Select("SELECT * from char_create_life"));
if(!events.IsValid() || events.Count() == 0)
return false;
for(unsigned int x = 0; x < events.Count(); x++)
{
LifeEventChoiceServer* choice = new LifeEventChoiceServer;
choice->id = events[x].GetInt(0);
choice->name = events[x][1];
choice->description = events[x][2];
choice->cpCost = events[x].GetInt(3);
choice->eventScript = events[x][4];
csString common = events[x][5];
choice->common = common.GetAt(0);
Result adds(db->Select("SELECT adds_choice from char_create_life_relations WHERE adds_choice IS NOT NULL AND choice=%d", choice->id));
if(!adds.IsValid())
{
delete choice;
return false;
}
for(unsigned int addIndex = 0; addIndex < adds.Count(); addIndex++)
{
choice->adds.Push(adds[addIndex].GetInt(0));
}
Result removes(db->Select("SELECT removes_choice from char_create_life_relations WHERE removes_choice IS NOT NULL AND choice=%d", choice->id));
if(!removes.IsValid())
{
delete choice;
return false;
}
for(unsigned int removesIndex = 0; removesIndex < removes.Count(); removesIndex++)
{
choice->removes.Push(removes[removesIndex].GetInt(0));
}
lifeEvents.Push(choice);
}
return true;
}
/* idx == -1 indicates main key
* otherwise the subkey.
*/
static void
print_key_fingerprint (gnutls_buffer_st * str, gnutls_openpgp_crt_t cert)
{
char fpr[128];
size_t fpr_size = sizeof (fpr);
int err;
err = gnutls_openpgp_crt_get_fingerprint (cert, fpr, &fpr_size);
if (err < 0)
addf (str, "error: get_fingerprint: %s\n", gnutls_strerror (err));
else
{
adds (str, _("\tFingerprint (hex): "));
hexprint (str, fpr, fpr_size);
addf (str, "\n");
}
}
/* idx == -1 indicates main key
* otherwise the subkey.
*/
static void
print_key_id(gnutls_buffer_st * str, gnutls_openpgp_crt_t cert, int idx)
{
gnutls_openpgp_keyid_t id;
int err;
if (idx < 0)
err = gnutls_openpgp_crt_get_key_id(cert, id);
else
err = gnutls_openpgp_crt_get_subkey_id(cert, idx, id);
if (err < 0)
addf(str, "error: get_key_id: %s\n", gnutls_strerror(err));
else {
adds(str, _("\tID (hex): "));
_gnutls_buffer_hexprint(str, id, sizeof(id));
addf(str, "\n");
}
}
void process(){
switch(comingbuf[0])
{
case '0' : search();
break;
case '1' : searchUS();
break;
case '2' : login();
break;
case '3' : regsiter();
break;
case '4' : adds();
break;
case '5' : removes();
break;
case '6' : logout();
break;
default : break;
}
}
int main() {
int n ,m;
int x ,y;
init();
while(cin >> n >> m, n+m) {
chu();
for(int i = 0 ;i < n;i++) {
scanf("%d%d",&x,&y);
adds(x,y);
}
for(int i = 0; i < m;i++) {
scanf("%d%d",&x,&y);
addh(x,y);
}
cout << solve() << endl;
}
return 0;
}
void unittest1()
{
bool overflow = false;
assert(adds(2, 3, overflow) == 5);
assert(!overflow);
assert(adds(1, INT32_MAX - 1, overflow) == INT32_MAX);
assert(!overflow);
assert(adds(INT32_MIN + 1, -1, overflow) == INT32_MIN);
assert(!overflow);
assert(adds(INT32_MAX, 1, overflow) == INT32_MIN);
assert(overflow);
overflow = false;
assert(adds(INT32_MIN, -1, overflow) == INT32_MAX);
assert(overflow);
assert(adds(0, 0, overflow) == 0);
assert(overflow); // sticky
}
void unittest2()
{
bool overflow = false;
assert(adds(2LL, 3LL, overflow) == 5);
assert(!overflow);
assert(adds(1LL, INT64_MAX - 1, overflow) == INT64_MAX);
assert(!overflow);
assert(adds(INT64_MIN + 1LL, -1LL, overflow) == INT64_MIN);
assert(!overflow);
assert(adds(INT64_MAX, 1LL, overflow) == INT64_MIN);
assert(overflow);
overflow = false;
assert(adds(INT64_MIN, -1LL, overflow) == INT64_MAX);
assert(overflow);
assert(adds(0LL, 0LL, overflow) == 0);
assert(overflow); // sticky
}
static void print_req(gnutls_buffer_st * str, gnutls_ocsp_req_t req)
{
int ret;
unsigned indx;
/* Version. */
{
int version = gnutls_ocsp_req_get_version(req);
if (version < 0)
addf(str, "error: get_version: %s\n",
gnutls_strerror(version));
else
addf(str, _("\tVersion: %d\n"), version);
}
/* XXX requestorName */
/* requestList */
addf(str, "\tRequest List:\n");
for (indx = 0;; indx++) {
gnutls_digest_algorithm_t digest;
gnutls_datum_t in, ik, sn;
ret =
gnutls_ocsp_req_get_cert_id(req, indx, &digest, &in,
&ik, &sn);
if (ret == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
break;
addf(str, "\t\tCertificate ID:\n");
if (ret != GNUTLS_E_SUCCESS) {
addf(str, "error: get_cert_id: %s\n",
gnutls_strerror(ret));
continue;
}
addf(str, "\t\t\tHash Algorithm: %s\n",
_gnutls_digest_get_name(hash_to_entry(digest)));
adds(str, "\t\t\tIssuer Name Hash: ");
_gnutls_buffer_hexprint(str, in.data, in.size);
adds(str, "\n");
adds(str, "\t\t\tIssuer Key Hash: ");
_gnutls_buffer_hexprint(str, ik.data, ik.size);
adds(str, "\n");
adds(str, "\t\t\tSerial Number: ");
_gnutls_buffer_hexprint(str, sn.data, sn.size);
adds(str, "\n");
gnutls_free(in.data);
gnutls_free(ik.data);
gnutls_free(sn.data);
/* XXX singleRequestExtensions */
}
for (indx = 0;; indx++) {
gnutls_datum_t oid;
unsigned int critical;
gnutls_datum_t data;
ret =
gnutls_ocsp_req_get_extension(req, indx, &oid,
&critical, &data);
if (ret == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
break;
else if (ret != GNUTLS_E_SUCCESS) {
addf(str, "error: get_extension: %s\n",
gnutls_strerror(ret));
continue;
}
if (indx == 0)
adds(str, "\tExtensions:\n");
if (oid.size == sizeof(GNUTLS_OCSP_NONCE) &&
memcmp(oid.data, GNUTLS_OCSP_NONCE, oid.size) == 0) {
gnutls_datum_t nonce;
unsigned int ncrit;
ret =
gnutls_ocsp_req_get_nonce(req, &ncrit,
&nonce);
if (ret != GNUTLS_E_SUCCESS) {
addf(str, "error: get_nonce: %s\n",
gnutls_strerror(ret));
} else {
addf(str, "\t\tNonce%s: ",
ncrit ? " (critical)" : "");
_gnutls_buffer_hexprint(str, nonce.data,
nonce.size);
adds(str, "\n");
gnutls_free(nonce.data);
}
} else {
addf(str, "\t\tUnknown extension %s (%s):\n",
oid.data,
critical ? "critical" : "not critical");
adds(str, _("\t\t\tASCII: "));
_gnutls_buffer_asciiprint(str, (char *) data.data,
data.size);
addf(str, "\n");
adds(str, _("\t\t\tHexdump: "));
_gnutls_buffer_hexprint(str, (char *) data.data,
data.size);
adds(str, "\n");
}
gnutls_free(oid.data);
gnutls_free(data.data);
}
/* XXX Signature */
}
ULONG fcmps(ULONG aa,ULONG bb,ULONG *dest)
{
FPNUM a,b,diff;
ULONG s,flag;
*dest = CP;
/* Reserved operand check */
flag = reserves(aa,bb,0);
if (flag != 0) return(flag);
flag = (flag<<FLAGWIDTH) | reserves(aa,bb,1);
if (flag != 0) return(flag);
if (flag) {
*dest = 0;
return(flag);
}
/* Extract fields, inverting the sign of the b operand */
a.sign = BFEXTU(aa,31,1);
b.sign = ! BFEXTU(bb,31,1);
a.exp = BFEXTU(aa,23,8);
b.exp = BFEXTU(bb,23,8);
a.mant = BFEXTU(aa,0,23);
b.mant = BFEXTU(bb,0,23);
/* Insert Hidden Bits */
if (a.exp != 0) a.mant |= HBITMASK;
if (b.exp != 0) b.mant |= HBITMASK;
/* Align operands */
aligns(a.exp,&a.mant,b.exp,&b.mant,&diff.exp,&s);
/* Calculate the difference */
adds(a.sign,a.mant,b.sign,b.mant,&diff.sign,&diff.mant,s);
b.sign = !b.sign; /* Make b.sign its original value for comparisons */
/* Calculate the comparison result register value */
if (b.sign == 0 || b.exp == 0)
/* (s1 > s2) || (s1 < 0) */
if ((a.exp > b.exp) || ((a.exp == b.exp) && (((!diff.sign) && diff.mant) > 0)) || (a.sign && a.exp))
*dest |= HI | HS;
/* (s2 > s1) && (s1 != 0) */
else if (((b.exp > a.exp) || ((a.exp == b.exp) && (b.mant > a.mant))) && a.exp)
*dest |= LO | LS;
/* s1 == s2 */
else
*dest |= LS | HS;
if ((diff.mant == 0) && (s == 0))
*dest |= EQ | LE | GE;
else {
*dest |= NE;
if (diff.sign)
*dest |= LT | LE;
else
*dest |= GT | GE;
}
return(flag);
}
static void
print_resp(gnutls_buffer_st * str, gnutls_ocsp_resp_t resp,
gnutls_ocsp_print_formats_t format)
{
int ret;
unsigned indx;
ret = gnutls_ocsp_resp_get_status(resp);
if (ret < 0) {
addf(str, "error: ocsp_resp_get_status: %s\n",
gnutls_strerror(ret));
return;
}
adds(str, "\tResponse Status: ");
switch (ret) {
case GNUTLS_OCSP_RESP_SUCCESSFUL:
adds(str, "Successful\n");
break;
case GNUTLS_OCSP_RESP_MALFORMEDREQUEST:
adds(str, "malformedRequest\n");
return;
case GNUTLS_OCSP_RESP_INTERNALERROR:
adds(str, "internalError\n");
return;
case GNUTLS_OCSP_RESP_TRYLATER:
adds(str, "tryLater\n");
return;
case GNUTLS_OCSP_RESP_SIGREQUIRED:
adds(str, "sigRequired\n");
return;
case GNUTLS_OCSP_RESP_UNAUTHORIZED:
adds(str, "unauthorized\n");
return;
default:
adds(str, "unknown\n");
return;
}
{
gnutls_datum_t oid;
ret = gnutls_ocsp_resp_get_response(resp, &oid, NULL);
if (ret < 0) {
addf(str, "error: get_response: %s\n",
gnutls_strerror(ret));
return;
}
adds(str, "\tResponse Type: ");
#define OCSP_BASIC "1.3.6.1.5.5.7.48.1.1"
if (oid.size == sizeof(OCSP_BASIC)
&& memcmp(oid.data, OCSP_BASIC, oid.size) == 0) {
adds(str, "Basic OCSP Response\n");
gnutls_free(oid.data);
} else {
addf(str, "Unknown response type (%.*s)\n",
oid.size, oid.data);
gnutls_free(oid.data);
return;
}
}
/* Version. */
{
int version = gnutls_ocsp_resp_get_version(resp);
if (version < 0)
addf(str, "error: get_version: %s\n",
gnutls_strerror(version));
else
addf(str, _("\tVersion: %d\n"), version);
}
/* responderID */
{
gnutls_datum_t dn;
ret = gnutls_ocsp_resp_get_responder(resp, &dn);
if (ret < 0 || dn.data == NULL) {
if (dn.data == 0) {
ret = gnutls_ocsp_resp_get_responder_raw_id(resp, GNUTLS_OCSP_RESP_ID_KEY, &dn);
if (ret >= 0) {
addf(str, _("\tResponder Key ID: "));
_gnutls_buffer_hexprint(str, dn.data, dn.size);
adds(str, "\n");
}
gnutls_free(dn.data);
} else {
addf(str, "error: get_dn: %s\n",
gnutls_strerror(ret));
}
} else {
if (dn.data != NULL) {
addf(str, _("\tResponder ID: %.*s\n"), dn.size,
dn.data);
gnutls_free(dn.data);
}
}
}
{
char s[42];
size_t max = sizeof(s);
struct tm t;
time_t tim = gnutls_ocsp_resp_get_produced(resp);
if (tim == (time_t) - 1)
addf(str, "error: ocsp_resp_get_produced\n");
else if (gmtime_r(&tim, &t) == NULL)
addf(str, "error: gmtime_r (%ld)\n",
(unsigned long) tim);
else if (strftime(s, max, "%a %b %d %H:%M:%S UTC %Y", &t)
== 0)
addf(str, "error: strftime (%ld)\n",
(unsigned long) tim);
else
addf(str, _("\tProduced At: %s\n"), s);
}
addf(str, "\tResponses:\n");
for (indx = 0;; indx++) {
gnutls_digest_algorithm_t digest;
gnutls_datum_t in, ik, sn;
unsigned int cert_status;
time_t this_update;
time_t next_update;
time_t revocation_time;
unsigned int revocation_reason;
ret = gnutls_ocsp_resp_get_single(resp,
indx,
&digest, &in, &ik, &sn,
&cert_status,
&this_update,
&next_update,
&revocation_time,
&revocation_reason);
if (ret == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
break;
addf(str, "\t\tCertificate ID:\n");
if (ret != GNUTLS_E_SUCCESS) {
addf(str, "error: get_singleresponse: %s\n",
gnutls_strerror(ret));
continue;
}
addf(str, "\t\t\tHash Algorithm: %s\n",
_gnutls_digest_get_name(hash_to_entry(digest)));
adds(str, "\t\t\tIssuer Name Hash: ");
_gnutls_buffer_hexprint(str, in.data, in.size);
adds(str, "\n");
adds(str, "\t\t\tIssuer Key Hash: ");
_gnutls_buffer_hexprint(str, ik.data, ik.size);
adds(str, "\n");
adds(str, "\t\t\tSerial Number: ");
_gnutls_buffer_hexprint(str, sn.data, sn.size);
adds(str, "\n");
gnutls_free(in.data);
gnutls_free(ik.data);
gnutls_free(sn.data);
{
const char *p = NULL;
switch (cert_status) {
case GNUTLS_OCSP_CERT_GOOD:
p = "good";
break;
case GNUTLS_OCSP_CERT_REVOKED:
p = "revoked";
break;
case GNUTLS_OCSP_CERT_UNKNOWN:
p = "unknown";
break;
default:
addf(str,
"\t\tCertificate Status: unexpected value %d\n",
cert_status);
break;
}
if (p)
addf(str, "\t\tCertificate Status: %s\n",
p);
}
/* XXX revocation reason */
if (cert_status == GNUTLS_OCSP_CERT_REVOKED) {
char s[42];
size_t max = sizeof(s);
struct tm t;
if (revocation_time == (time_t) - 1)
addf(str, "error: revocation_time\n");
else if (gmtime_r(&revocation_time, &t) == NULL)
addf(str, "error: gmtime_r (%ld)\n",
(unsigned long) revocation_time);
else if (strftime
(s, max, "%a %b %d %H:%M:%S UTC %Y",
&t) == 0)
addf(str, "error: strftime (%ld)\n",
(unsigned long) revocation_time);
else
addf(str, _("\t\tRevocation time: %s\n"),
s);
}
{
char s[42];
size_t max = sizeof(s);
struct tm t;
if (this_update == (time_t) - 1)
addf(str, "error: this_update\n");
else if (gmtime_r(&this_update, &t) == NULL)
addf(str, "error: gmtime_r (%ld)\n",
(unsigned long) this_update);
else if (strftime
(s, max, "%a %b %d %H:%M:%S UTC %Y",
&t) == 0)
addf(str, "error: strftime (%ld)\n",
(unsigned long) this_update);
else
addf(str, _("\t\tThis Update: %s\n"), s);
}
{
char s[42];
size_t max = sizeof(s);
struct tm t;
if (next_update != (time_t) - 1) {
if (gmtime_r(&next_update, &t) == NULL)
addf(str, "error: gmtime_r (%ld)\n",
(unsigned long) next_update);
else if (strftime
(s, max, "%a %b %d %H:%M:%S UTC %Y",
&t) == 0)
addf(str, "error: strftime (%ld)\n",
(unsigned long) next_update);
else
addf(str, _("\t\tNext Update: %s\n"), s);
}
}
/* XXX singleRequestExtensions */
}
adds(str, "\tExtensions:\n");
for (indx = 0;; indx++) {
gnutls_datum_t oid;
unsigned int critical;
gnutls_datum_t data;
ret =
gnutls_ocsp_resp_get_extension(resp, indx, &oid,
&critical, &data);
if (ret == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
break;
else if (ret != GNUTLS_E_SUCCESS) {
addf(str, "error: get_extension: %s\n",
gnutls_strerror(ret));
continue;
}
if (oid.size == sizeof(GNUTLS_OCSP_NONCE) &&
memcmp(oid.data, GNUTLS_OCSP_NONCE, oid.size) == 0) {
gnutls_datum_t nonce;
unsigned int ncrit;
ret =
gnutls_ocsp_resp_get_nonce(resp, &ncrit,
&nonce);
if (ret != GNUTLS_E_SUCCESS) {
addf(str, "error: get_nonce: %s\n",
gnutls_strerror(ret));
} else {
addf(str, "\t\tNonce%s: ",
ncrit ? " (critical)" : "");
_gnutls_buffer_hexprint(str, nonce.data,
nonce.size);
adds(str, "\n");
gnutls_free(nonce.data);
}
} else {
addf(str, "\t\tUnknown extension %s (%s):\n",
oid.data,
critical ? "critical" : "not critical");
adds(str, _("\t\t\tASCII: "));
_gnutls_buffer_asciiprint(str, (char *) data.data,
data.size);
addf(str, "\n");
adds(str, _("\t\t\tHexdump: "));
_gnutls_buffer_hexprint(str, (char *) data.data,
data.size);
adds(str, "\n");
}
gnutls_free(oid.data);
gnutls_free(data.data);
}
/* Signature. */
if (format == GNUTLS_OCSP_PRINT_FULL) {
gnutls_datum_t sig;
ret = gnutls_ocsp_resp_get_signature_algorithm(resp);
if (ret < 0)
addf(str, "error: get_signature_algorithm: %s\n",
gnutls_strerror(ret));
else {
const char *name =
gnutls_sign_algorithm_get_name(ret);
if (name == NULL)
name = _("unknown");
addf(str, _("\tSignature Algorithm: %s\n"), name);
}
if (ret != GNUTLS_SIGN_UNKNOWN && gnutls_sign_is_secure(ret) == 0) {
adds(str,
_("warning: signed using a broken signature "
"algorithm that can be forged.\n"));
}
ret = gnutls_ocsp_resp_get_signature(resp, &sig);
if (ret < 0)
addf(str, "error: get_signature: %s\n",
gnutls_strerror(ret));
else {
adds(str, _("\tSignature:\n"));
_gnutls_buffer_hexdump(str, sig.data, sig.size,
"\t\t");
gnutls_free(sig.data);
}
}
/* certs */
if (format == GNUTLS_OCSP_PRINT_FULL) {
gnutls_x509_crt_t *certs;
size_t ncerts, i;
gnutls_datum_t out;
ret = gnutls_ocsp_resp_get_certs(resp, &certs, &ncerts);
if (ret < 0)
addf(str, "error: get_certs: %s\n",
gnutls_strerror(ret));
else {
if (ncerts > 0)
addf(str, "\tAdditional certificates:\n");
for (i = 0; i < ncerts; i++) {
size_t s = 0;
ret =
gnutls_x509_crt_print(certs[i],
GNUTLS_CRT_PRINT_FULL,
&out);
if (ret < 0)
addf(str, "error: crt_print: %s\n",
gnutls_strerror(ret));
else {
addf(str, "%.*s", out.size,
out.data);
gnutls_free(out.data);
}
ret =
gnutls_x509_crt_export(certs[i],
GNUTLS_X509_FMT_PEM,
NULL, &s);
if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
addf(str,
"error: crt_export: %s\n",
gnutls_strerror(ret));
else {
out.data = gnutls_malloc(s);
if (out.data == NULL)
addf(str,
"error: malloc: %s\n",
gnutls_strerror
(GNUTLS_E_MEMORY_ERROR));
else {
ret =
gnutls_x509_crt_export
(certs[i],
GNUTLS_X509_FMT_PEM,
out.data, &s);
if (ret < 0)
addf(str,
"error: crt_export: %s\n",
gnutls_strerror
(ret));
else {
out.size = s;
addf(str, "%.*s",
out.size,
out.data);
}
gnutls_free(out.data);
}
}
gnutls_x509_crt_deinit(certs[i]);
}
gnutls_free(certs);
}
}
}
/**
* gnutls_pkcs7_crt_print:
* @pkcs7: The PKCS7 struct to be printed
* @format: Indicate the format to use
* @out: Newly allocated datum with null terminated string.
*
* This function will pretty print a signed PKCS #7 structure, suitable for
* display to a human.
*
* Currently the supported formats are %GNUTLS_CRT_PRINT_FULL and
* %GNUTLS_CRT_PRINT_COMPACT.
*
* The output @out needs to be deallocated using gnutls_free().
*
* Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a
* negative error value.
**/
int gnutls_pkcs7_print(gnutls_pkcs7_t pkcs7,
gnutls_certificate_print_formats_t format,
gnutls_datum_t * out)
{
int count, ret, i;
gnutls_pkcs7_signature_info_st info;
gnutls_buffer_st str;
const char *oid;
_gnutls_buffer_init(&str);
/* For backwards compatibility with structures using the default OID,
* we don't print the eContent Type explicitly */
oid = gnutls_pkcs7_get_embedded_data_oid(pkcs7);
if (oid) {
if (strcmp(oid, DATA_OID) != 0
&& strcmp(oid, DIGESTED_DATA_OID) != 0) {
addf(&str, "eContent Type: %s\n", oid);
}
}
for (i = 0;; i++) {
if (i == 0)
addf(&str, "Signers:\n");
ret = gnutls_pkcs7_get_signature_info(pkcs7, i, &info);
if (ret < 0)
break;
print_pkcs7_info(&info, &str, format);
gnutls_pkcs7_signature_info_deinit(&info);
}
if (format == GNUTLS_CRT_PRINT_FULL) {
gnutls_datum_t data, b64;
count = gnutls_pkcs7_get_crt_count(pkcs7);
if (count > 0) {
addf(&str, "Number of certificates: %u\n\n",
count);
for (i = 0; i < count; i++) {
ret =
gnutls_pkcs7_get_crt_raw2(pkcs7, i, &data);
if (ret < 0) {
addf(&str,
"Error: cannot print certificate %d\n",
i);
continue;
}
ret =
gnutls_pem_base64_encode_alloc
("CERTIFICATE", &data, &b64);
if (ret < 0) {
gnutls_free(data.data);
continue;
}
adds(&str, (char*)b64.data);
adds(&str, "\n");
gnutls_free(b64.data);
gnutls_free(data.data);
}
}
count = gnutls_pkcs7_get_crl_count(pkcs7);
if (count > 0) {
addf(&str, "Number of CRLs: %u\n\n", count);
for (i = 0; i < count; i++) {
ret =
gnutls_pkcs7_get_crl_raw2(pkcs7, i, &data);
if (ret < 0) {
addf(&str,
"Error: cannot print certificate %d\n",
i);
continue;
}
ret =
gnutls_pem_base64_encode_alloc("X509 CRL",
&data, &b64);
if (ret < 0) {
gnutls_free(data.data);
continue;
}
adds(&str, (char*)b64.data);
adds(&str, "\n");
gnutls_free(b64.data);
gnutls_free(data.data);
}
}
}
return _gnutls_buffer_to_datum(&str, out, 1);
}
static void print_pkcs7_info(gnutls_pkcs7_signature_info_st * info,
gnutls_buffer_st * str,
gnutls_certificate_print_formats_t format)
{
unsigned i;
char *oid;
gnutls_datum_t data;
char prefix[128];
char s[42];
size_t max;
int ret;
if (info->issuer_dn.size > 0)
print_dn(str, "\tSigner's issuer DN", &info->issuer_dn);
print_raw(str, "\tSigner's serial", &info->signer_serial);
print_raw(str, "\tSigner's issuer key ID", &info->issuer_keyid);
if (info->signing_time != -1) {
struct tm t;
if (gmtime_r(&info->signing_time, &t) == NULL) {
addf(str, "error: gmtime_r (%ld)\n",
(unsigned long)info->signing_time);
} else {
max = sizeof(s);
if (strftime(s, max, "%a %b %d %H:%M:%S UTC %Y", &t) ==
0) {
addf(str, "error: strftime (%ld)\n",
(unsigned long)info->signing_time);
} else {
addf(str, "\tSigning time: %s\n", s);
}
}
}
addf(str, "\tSignature Algorithm: %s\n",
gnutls_sign_get_name(info->algo));
if (format == GNUTLS_CRT_PRINT_FULL) {
if (info->signed_attrs) {
for (i = 0;; i++) {
ret =
gnutls_pkcs7_get_attr(info->signed_attrs, i,
&oid, &data, 0);
if (ret < 0)
break;
if (i == 0)
addf(str, "\tSigned Attributes:\n");
snprintf(prefix, sizeof(prefix), "\t\t%s", oid);
print_raw(str, prefix, &data);
gnutls_free(data.data);
}
}
if (info->unsigned_attrs) {
for (i = 0;; i++) {
ret =
gnutls_pkcs7_get_attr(info->unsigned_attrs,
i, &oid, &data, 0);
if (ret < 0)
break;
if (i == 0)
addf(str, "\tUnsigned Attributes:\n");
snprintf(prefix, sizeof(prefix), "\t\t%s", oid);
print_raw(str, prefix, &data);
gnutls_free(data.data);
}
}
}
adds(str, "\n");
}
static void
print_key_info(gnutls_buffer_st * str, gnutls_openpgp_crt_t cert, int idx)
{
int err;
unsigned int bits;
if (idx == -1)
err = gnutls_openpgp_crt_get_pk_algorithm(cert, &bits);
else
err =
gnutls_openpgp_crt_get_subkey_pk_algorithm(cert, idx,
&bits);
if (err < 0)
addf(str, "error: get_pk_algorithm: %s\n",
gnutls_strerror(err));
else {
const char *name = gnutls_pk_algorithm_get_name(err);
if (name == NULL)
name = _("unknown");
addf(str, _("\tPublic Key Algorithm: %s\n"), name);
addf(str, _("\tKey Security Level: %s\n"),
gnutls_sec_param_get_name(gnutls_pk_bits_to_sec_param
(err, bits)));
switch (err) {
case GNUTLS_PK_RSA:
{
gnutls_datum_t m, e;
if (idx == -1)
err =
gnutls_openpgp_crt_get_pk_rsa_raw
(cert, &m, &e);
else
err =
gnutls_openpgp_crt_get_subkey_pk_rsa_raw
(cert, idx, &m, &e);
if (err < 0)
addf(str,
"error: get_pk_rsa_raw: %s\n",
gnutls_strerror(err));
else {
addf(str,
_("\t\tModulus (bits %d):\n"),
bits);
_gnutls_buffer_hexdump(str, m.data,
m.size,
"\t\t\t");
adds(str, _("\t\tExponent:\n"));
_gnutls_buffer_hexdump(str, e.data,
e.size,
"\t\t\t");
gnutls_free(m.data);
gnutls_free(e.data);
}
}
break;
case GNUTLS_PK_DSA:
{
gnutls_datum_t p, q, g, y;
if (idx == -1)
err =
gnutls_openpgp_crt_get_pk_dsa_raw
(cert, &p, &q, &g, &y);
else
err =
gnutls_openpgp_crt_get_subkey_pk_dsa_raw
(cert, idx, &p, &q, &g, &y);
if (err < 0)
addf(str,
"error: get_pk_dsa_raw: %s\n",
gnutls_strerror(err));
else {
addf(str,
_
("\t\tPublic key (bits %d):\n"),
bits);
_gnutls_buffer_hexdump(str, y.data,
y.size,
"\t\t\t");
adds(str, _("\t\tP:\n"));
_gnutls_buffer_hexdump(str, p.data,
p.size,
"\t\t\t");
adds(str, _("\t\tQ:\n"));
_gnutls_buffer_hexdump(str, q.data,
q.size,
"\t\t\t");
adds(str, _("\t\tG:\n"));
_gnutls_buffer_hexdump(str, g.data,
g.size,
"\t\t\t");
gnutls_free(p.data);
gnutls_free(q.data);
gnutls_free(g.data);
gnutls_free(y.data);
}
}
break;
default:
break;
}
}
}
static void
print_oneline(gnutls_buffer_st * str, gnutls_openpgp_crt_t cert)
{
int err, i;
i = 0;
do {
char *dn;
size_t dn_size = 0;
err = gnutls_openpgp_crt_get_name(cert, i, NULL, &dn_size);
if (err != GNUTLS_E_SHORT_MEMORY_BUFFER
&& err != GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
&& err != GNUTLS_E_OPENPGP_UID_REVOKED)
addf(str, "unknown name (%s), ",
gnutls_strerror(err));
else {
dn = gnutls_malloc(dn_size);
if (!dn)
addf(str, "unknown name (%s), ",
gnutls_strerror
(GNUTLS_E_MEMORY_ERROR));
else {
err =
gnutls_openpgp_crt_get_name(cert, i,
dn,
&dn_size);
if (err < 0
&& err !=
GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
&& err != GNUTLS_E_OPENPGP_UID_REVOKED)
addf(str, "unknown name (%s), ",
gnutls_strerror(err));
else if (err >= 0)
addf(str, _("name[%d]: %s, "), i,
dn);
else if (err ==
GNUTLS_E_OPENPGP_UID_REVOKED)
addf(str,
_("revoked name[%d]: %s, "),
i, dn);
gnutls_free(dn);
}
}
i++;
}
while (err >= 0);
{
char fpr[128];
size_t fpr_size = sizeof(fpr);
int err;
err =
gnutls_openpgp_crt_get_fingerprint(cert, fpr,
&fpr_size);
if (err < 0)
addf(str, "error: get_fingerprint: %s\n",
gnutls_strerror(err));
else {
adds(str, _("fingerprint: "));
_gnutls_buffer_hexprint(str, fpr, fpr_size);
addf(str, ", ");
}
}
{
time_t tim;
tim = gnutls_openpgp_crt_get_creation_time(cert);
{
char s[42];
size_t max = sizeof(s);
struct tm t;
if (gmtime_r(&tim, &t) == NULL)
addf(str, "error: gmtime_r (%ld), ",
(unsigned long) tim);
else if (strftime
(s, max, "%Y-%m-%d %H:%M:%S UTC",
&t) == 0)
addf(str, "error: strftime (%ld), ",
(unsigned long) tim);
else
addf(str, _("created: %s, "), s);
}
tim = gnutls_openpgp_crt_get_expiration_time(cert);
{
char s[42];
size_t max = sizeof(s);
struct tm t;
if (tim == 0)
adds(str, _("never expires, "));
else {
if (gmtime_r(&tim, &t) == NULL)
addf(str,
"error: gmtime_r (%ld), ",
(unsigned long) tim);
else if (strftime
(s, max, "%Y-%m-%d %H:%M:%S UTC",
&t) == 0)
addf(str,
"error: strftime (%ld), ",
(unsigned long) tim);
else
addf(str, _("expires: %s, "), s);
}
}
}
{
unsigned int bits = 0;
gnutls_pk_algorithm_t algo =
gnutls_openpgp_crt_get_pk_algorithm(cert, &bits);
const char *algostr = gnutls_pk_algorithm_get_name(algo);
if (algostr)
addf(str, _("key algorithm %s (%d bits)"), algostr,
bits);
else
addf(str, _("unknown key algorithm (%d)"), algo);
}
}
slug getslug(FILE *fp)
{
if (inbuf == NULL) {
if ((inbuf = (char *)malloc(ninbuf = DELTABUF)) == NULL)
ERROR "no room for %ld character input buffer\n", ninbuf FATAL;
inbp = inbuf;
}
if (wherebuf() > (ssize_t)(ninbuf-5000)) {
// this is still flaky -- lines can be very long
int where = wherebuf(); // where we were
if ((inbuf = (char *)realloc(inbuf, ninbuf += DELTABUF)) == NULL)
ERROR "no room for %ld character input buffer\n", ninbuf FATAL;
ERROR "grew input buffer to %ld characters\n", ninbuf WARNING;
inbp = inbuf + where; // same offset in new array
}
static int baseV = 0; // first V command of preceding slug
static int curV = 0, curH = 0;
static int font = 0, size = 0;
static int baseadj = 0;
static int ncol = 1, offset = 0; // multi-column stuff
char str[1000], str2[1000], buf[3000], *p;
int firstV = 0, firstH = 0;
int maxV = curV;
int ocurV = curV, mxv = 0, dx = 0;
int sawD = 0; // > 0 if have seen D...
slug ret;
ret.serialnum = serialnum++;
ret.type = VBOX; // use the same as last by default
ret.dv = curV - baseV;
ret.hpos = curH;
ret.base = ret.parm = ret.parm2 = ret.seen = 0;
ret.font = font;
ret.size = size;
ret.dp = wherebuf();
ret.ncol = ncol;
ret.offset = offset;
ret.linenum = linenum; // might be low
for (;;) {
int c, m, n; // for input values
int sign; // hoisted from case 'h' below
switch (c = getc(fp)) {
case EOF:
ret.type = EOF;
ret.dv = 0;
if (baseadj)
printf("# adjusted %d bases\n", baseadj);
printf("# %d characters, %d lines\n", wherebuf(), linenum);
return ret;
case 'V':
fscanf(fp, "%d", &n);
if (firstV++ == 0) {
ret.dv = n - baseV;
baseV = n;
} else {
sprintf(buf, "v%d", n - curV);
adds(buf);
}
curV = n;
maxV = max(maxV, curV);
break;
case 'H': // absolute H motion
fscanf(fp, "%d", &n);
if (firstH++ == 0) {
ret.hpos = n;
} else {
sprintf(buf, "h%d", n - curH);
adds(buf);
}
curH = n;
break;
case 'h': // relative H motion
addc(c);
sign = 1;
if ((c = getc(fp)) == '-') {
addc(c);
sign = -1;
c = getc(fp);
}
for (n = 0; isdigit(c); c = getc(fp)) {
addc(c);
n = 10 * n + c - '0';
}
curH += n * sign;
ungetc(c, fp);
break;
case 'x': // device control: x ...
addc(c);
fgets(buf, sizeof(buf), fp);
linenum++;
adds(buf);
if (buf[0] == ' ' && buf[1] == 'X') { // x X ...
if (2 != sscanf(buf+2, "%s %d", str, &n))
n = 0;
if (eq(str, "SP")) { // X SP n
ret.type = SP; // paddable SPace
ret.dv = n; // of height n
} else if (eq(str, "BS")) {
ret.type = BS; // Breakable Stream
ret.parm = n; // >=n VBOXES on a page
} else if (eq(str, "BF")) {
ret.type = BF; // Breakable Float
ret.parm = ret.parm2 = n;
// n = pref center (as UF)
} else if (eq(str, "US")) {
ret.type = US; // Unbreakable Stream
ret.parm = n;
} else if (eq(str, "UF")) {
ret.type = UF; // Unbreakable Float
ret.parm = ret.parm2 = n;
// n = preferred center
// to select several,
// use several UF lines
} else if (eq(str, "PT")) {
ret.type = PT; // Page Title
ret.parm = n;
} else if (eq(str, "BT")) {
ret.type = BT; // Bottom Title
ret.parm = n;
} else if (eq(str, "END")) {
ret.type = END;
ret.parm = n;
} else if (eq(str, "TM")) {
ret.type = TM; // Terminal Message
ret.dv = 0;
} else if (eq(str, "COORD")) {
ret.type = COORD;// page COORDinates
ret.dv = 0;
} else if (eq(str, "NE")) {
ret.type = NE; // NEed to break page
ret.dv = n; // if <n units left
} else if (eq(str, "MC")) {
ret.type = MC; // Multiple Columns
sscanf(buf+2, "%s %d %d",
str, &ncol, &offset);
ret.ncol = ncol;
ret.offset = offset;
} else if (eq(str, "CMD")) {
ret.type = CMD; // CoMmaNd
sscanf(buf+2, "%s %s", str2, str);
if (eq(str, "FC")) // Freeze 2-Col
ret.parm = FC;
else if (eq(str, "FL")) // FLush
ret.parm = FL;
else if (eq(str, "BP")) // Break Page
ret.parm = BP;
else ERROR "unknown command %s\n",
str WARNING;
} else if (eq(str, "PARM")) {
ret.type = PARM;// PARaMeter
sscanf(buf+2, "%s %s %d", str2, str, &ret.parm2);
if (eq(str, "NP")) // New Page
ret.parm = NP;
else if (eq(str, "FO")) // FOoter
ret.parm = FO;
else if (eq(str, "PL")) // Page Length
ret.parm = PL;
else if (eq(str, "MF")) // MinFull
ret.parm = MF;
else if (eq(str, "CT")) // ColTol
ret.parm = CT;
else if (eq(str, "WARN")) //WARNings?
ret.parm = WARN;
else if (eq(str, "DBG"))// DeBuG
ret.parm = DBG;
else ERROR "unknown parameter %s\n",
str WARNING;
} else
break; // out of switch
if (firstV > 0)
ERROR "weird x X %s in mid-VBOX\n",
str WARNING;
return ret;
}
break;
case 'n': // end of line
fscanf(fp, "%d %d", &n, &m);
ret.ht = n;
ret.base = m;
getc(fp); // newline
linenum++;
sprintf(buf, "n%d %d\n", ret.ht, ret.base);
adds(buf);
if (!firstV++)
baseV = curV;
// older incarnations of this program used ret.base
// in complicated and unreliable ways;
// example: if ret.ht + ret.base < ret.dv, ret.base = 0
// this was meant to avoid double-counting the space
// around displayed equations; it didn't work
// Now, we believe ret.base = 0, otherwise we give it
// a value we have computed.
if (ret.base == 0 && sawD == 0)
return ret; // don't fiddle 0-bases
if (ret.base != maxV - baseV) {
ret.base = maxV - baseV;
baseadj++;
}
if (ret.type != VBOX)
ERROR "%s slug (type %d) has base = %d\n",
ret.type_name(), ret.type, ret.base WARNING;
return ret;
case 'p': // new page
fscanf(fp, "%d", &n);
ret.type = PAGE;
curV = baseV = ret.dv = 0;
ret.parm = n; // just in case someone needs it
return ret;
case 's': // size change snnn
fscanf(fp, "%d", &size);
sprintf(buf, "s%d\n", size);
adds(buf);
break;
case 'f': // font fnnn
fscanf(fp, "%d", &font);
sprintf(buf, "f%d\n", font);
adds(buf);
break;
case '\n':
linenum++;
/* fall through */
case ' ':
addc(c);
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
// two motion digits plus a character
addc(c);
n = c - '0';
addc(c = getc(fp));
curH += 10 * n + c - '0';
addc(getc(fp));
if (!firstV++)
baseV = curV;
break;
case 'c': // single ascii character
addc(c);
addc(getc(fp));
if (!firstV++)
baseV = curV;
break;
case 'C': // Cxyz\n
case 'N': // Nnnn\n
addc(c);
while ((c = getc(fp)) != ' ' && c != '\n')
addc(c);
addc(c);
if (!firstV++)
baseV = curV;
linenum++;
break;
case 'D': // draw function: D.*\n
sawD++;
p = bufptr(wherebuf()); // where does the D start
addc(c);
while ((c = getc(fp)) != '\n')
addc(c);
addc(c);
if (!firstV++)
baseV = curV;
ocurV = curV, mxv = 0, dx = 0;
curV += getDy(p, &dx, &mxv); // figure out how big it is
maxV = max(max(maxV, curV), ocurV+mxv);
curH += dx;
linenum++;
break;
case 'v': // relative vertical vnnn
addc(c);
if (!firstV++)
baseV = curV;
sign = 1;
if ((c = getc(fp)) == '-') {
addc(c);
sign = -1;
c = getc(fp);
}
for (n = 0; isdigit(c); c = getc(fp)) {
addc(c);
n = 10 * n + c - '0';
}
ungetc(c, fp);
curV += n * sign;
maxV = max(maxV, curV);
addc('\n');
break;
case 'w': // word space
addc(c);
break;
case '#': // comment
addc(c);
while ((c = getc(fp)) != '\n')
addc(c);
addc('\n');
linenum++;
break;
default:
ERROR "unknown input character %o %c (%50.50s)\n",
c, c, bufptr(wherebuf()-50) WARNING;
break;
}
}
}