void tpic_output::command(const char *s, const char *filename, int lineno)
{
assert(s[0] == '.');
if (s[1] == 'p' && s[2] == 's' && (s[3] == '\0' || !csalpha(s[3]))) {
const char *p = s + 3;
while (csspace(*p))
p++;
if (*p == '\0') {
int temp = default_pen_size;
default_pen_size = prev_default_pen_size;
prev_default_pen_size = temp;
}
else {
char *ptr;
int temp = (int)strtol(p, &ptr, 10);
if (temp == 0 && ptr == p)
error_with_file_and_line(filename, lineno,
"argument to `.ps' not an integer");
else if (temp < 0)
error_with_file_and_line(filename, lineno,
"negative pen size");
else {
prev_default_pen_size = default_pen_size;
default_pen_size = temp;
}
}
}
else
printf("\\%s%%\n", s + 1);
}
char *get_thru_arg()
{
int c = input_stack::peek_char();
while (c == ' ') {
input_stack::get_char();
c = input_stack::peek_char();
}
if (c != EOF && csalpha(c)) {
// looks like a macro
input_stack::get_char();
token_buffer = c;
for (;;) {
c = input_stack::peek_char();
if (c == EOF || (!csalnum(c) && c != '_'))
break;
input_stack::get_char();
token_buffer += char(c);
}
context_buffer = token_buffer;
token_buffer += '\0';
char *def = macro_table.lookup(token_buffer.contents());
if (def)
return strsave(def);
// I guess it wasn't a macro after all; so push the macro name back.
// -2 because we added a '\0'
for (int i = token_buffer.length() - 2; i >= 0; i--)
input_stack::push_back(token_buffer[i]);
}
if (get_delimited()) {
token_buffer += '\0';
return strsave(token_buffer.contents());
}
else
return 0;
}
void token_info::sortify(const char *start, const char *end, string &result)
const
{
if (sort_key)
result += sort_key;
else if (type == TOKEN_UPPER || type == TOKEN_LOWER) {
for (; start < end; start++)
if (csalpha(*start))
result += cmlower(*start);
}
}
int token_info::sortify_non_empty(const char *start, const char *end) const
{
if (sort_key)
return *sort_key != '\0';
if (type != TOKEN_UPPER && type != TOKEN_LOWER)
return 0;
for (; start < end; start++)
if (csalpha(*start))
return 1;
return 0;
}
static int find_month(const char *start, const char *end)
{
static const char *months[] = {
"january",
"february",
"march",
"april",
"may",
"june",
"july",
"august",
"september",
"october",
"november",
"december",
};
for (;;) {
while (start < end && !csalpha(*start))
start++;
const char *ptr = start;
if (start == end)
break;
while (ptr < end && csalpha(*ptr))
ptr++;
if (ptr - start >= 3) {
for (unsigned int i = 0; i < sizeof(months)/sizeof(months[0]); i++) {
const char *q = months[i];
const char *p = start;
for (; p < ptr; p++, q++)
if (cmlower(*p) != *q)
break;
if (p >= ptr)
return i;
}
}
start = ptr;
}
return -1;
}
void init_char_table()
{
set_special_char_type("pl", 2, -1); // binary
set_special_char_type("mi", 2, -1);
set_special_char_type("eq", 3, -1); // relation
set_special_char_type("<=", 3, -1);
set_special_char_type(">=", 3, -1);
char_table['}'].spacing_type = 5; // closing
char_table[')'].spacing_type = 5;
char_table[']'].spacing_type = 5;
char_table['{'].spacing_type = 4; // opening
char_table['('].spacing_type = 4;
char_table['['].spacing_type = 4;
char_table[','].spacing_type = 6; // punctuation
char_table[';'].spacing_type = 6;
char_table[':'].spacing_type = 6;
char_table['.'].spacing_type = 6;
char_table['>'].spacing_type = 3;
char_table['<'].spacing_type = 3;
char_table['*'].spacing_type = 2; // binary
for (int i = 0; i < 256; i++)
if (csalpha(i))
char_table[i].font_type = LETTER_TYPE;
}
void ps_printer::do_import(char *arg, const environment *env)
{
while (*arg == ' ' || *arg == '\n')
arg++;
char *p;
for (p = arg; *p != '\0' && *p != ' ' && *p != '\n'; p++)
;
if (*p != '\0')
*p++ = '\0';
int parms[6];
int nparms = 0;
while (nparms < 6) {
char *end;
long n = strtol(p, &end, 10);
if (n == 0 && end == p)
break;
parms[nparms++] = int(n);
p = end;
}
if (csalpha(*p) && (p[1] == '\0' || p[1] == ' ' || p[1] == '\n')) {
error("scaling indicators not allowed in arguments for X import command");
return;
}
while (*p == ' ' || *p == '\n')
p++;
if (nparms < 5) {
if (*p == '\0')
error("too few arguments for X import command");
else
error("invalid argument `%1' for X import command", p);
return;
}
if (*p != '\0') {
error("superfluous argument `%1' for X import command", p);
return;
}
int llx = parms[0];
int lly = parms[1];
int urx = parms[2];
int ury = parms[3];
int desired_width = parms[4];
int desired_height = parms[5];
if (desired_width <= 0) {
error("bad width argument `%1' for X import command: must be > 0",
desired_width);
return;
}
if (nparms == 6 && desired_height <= 0) {
error("bad height argument `%1' for X import command: must be > 0",
desired_height);
return;
}
if (llx == urx) {
error("llx and urx arguments for X import command must not be equal");
return;
}
if (lly == ury) {
error("lly and ury arguments for X import command must not be equal");
return;
}
if (nparms == 5) {
int old_wid = urx - llx;
int old_ht = ury - lly;
if (old_wid < 0)
old_wid = -old_wid;
if (old_ht < 0)
old_ht = -old_ht;
desired_height = int(desired_width*(double(old_ht)/double(old_wid)) + .5);
}
if (env->vpos - desired_height < 0)
warning("top of imported graphic is above the top of the page");
out.put_number(llx)
.put_number(lly)
.put_fix_number(desired_width)
.put_number(urx - llx)
.put_fix_number(-desired_height)
.put_number(ury - lly)
.put_fix_number(env->hpos)
.put_fix_number(env->vpos)
.put_symbol("PBEGIN");
rm.import_file(arg, out);
// do this here just in case application defines PEND
out.put_symbol("end")
.put_symbol("PEND");
}
options *process_options(table_input &in)
{
options *opt = new options;
string line;
int level = 0;
for (;;) {
int c = in.get();
if (c == EOF) {
int i = line.length();
while (--i >= 0)
in.unget(line[i]);
return opt;
}
if (c == '\n') {
in.unget(c);
int i = line.length();
while (--i >= 0)
in.unget(line[i]);
return opt;
}
else if (c == '(')
level++;
else if (c == ')')
level--;
else if (c == ';' && level == 0) {
line += '\0';
break;
}
line += c;
}
if (line.empty())
return opt;
char *p = &line[0];
for (;;) {
while (!csalpha(*p) && *p != '\0')
p++;
if (*p == '\0')
break;
char *q = p;
while (csalpha(*q))
q++;
char *arg = 0;
if (*q != '(' && *q != '\0')
*q++ = '\0';
while (csspace(*q))
q++;
if (*q == '(') {
*q++ = '\0';
arg = q;
while (*q != ')' && *q != '\0')
q++;
if (*q == '\0')
error("missing `)'");
else
*q++ = '\0';
}
if (*p == '\0') {
if (arg)
error("argument without option");
}
else if (strieq(p, "tab")) {
if (!arg)
error("`tab' option requires argument in parentheses");
else {
if (arg[0] == '\0' || arg[1] != '\0')
error("argument to `tab' option must be a single character");
else
opt->tab_char = arg[0];
}
}
else if (strieq(p, "linesize")) {
if (!arg)
error("`linesize' option requires argument in parentheses");
else {
if (sscanf(arg, "%d", &opt->linesize) != 1)
error("bad linesize `%s'", arg);
else if (opt->linesize <= 0) {
error("linesize must be positive");
opt->linesize = 0;
}
}
}
else if (strieq(p, "delim")) {
if (!arg)
error("`delim' option requires argument in parentheses");
else if (arg[0] == '\0' || arg[1] == '\0' || arg[2] != '\0')
error("argument to `delim' option must be two characters");
else {
opt->delim[0] = arg[0];
opt->delim[1] = arg[1];
}
}
else if (strieq(p, "center") || strieq(p, "centre")) {
if (arg)
error("`center' option does not take an argument");
opt->flags |= table::CENTER;
}
else if (strieq(p, "expand")) {
if (arg)
error("`expand' option does not take an argument");
opt->flags |= table::EXPAND;
}
else if (strieq(p, "box") || strieq(p, "frame")) {
if (arg)
error("`box' option does not take an argument");
opt->flags |= table::BOX;
}
else if (strieq(p, "doublebox") || strieq(p, "doubleframe")) {
if (arg)
error("`doublebox' option does not take an argument");
opt->flags |= table::DOUBLEBOX;
}
else if (strieq(p, "allbox")) {
if (arg)
error("`allbox' option does not take an argument");
opt->flags |= table::ALLBOX;
}
else if (strieq(p, "nokeep")) {
if (arg)
error("`nokeep' option does not take an argument");
opt->flags |= table::NOKEEP;
}
else if (strieq(p, "nospaces")) {
if (arg)
error("`nospaces' option does not take an argument");
opt->flags |= table::NOSPACES;
}
else if (strieq(p, "decimalpoint")) {
if (!arg)
error("`decimalpoint' option requires argument in parentheses");
else {
if (arg[0] == '\0' || arg[1] != '\0')
error("argument to `decimalpoint' option must be a single character");
else
opt->decimal_point_char = arg[0];
}
}
else if (strieq(p, "experimental")) {
opt->flags |= table::EXPERIMENTAL;
}
else {
error("unrecognised global option `%1'", p);
// delete opt;
// return 0;
}
p = q;
}
return opt;
}
int get_token(int lookup_flag)
{
context_buffer.clear();
for (;;) {
int n = 0;
int bol = input_stack::bol();
int c = input_stack::get_char();
if (bol && c == command_char) {
token_buffer.clear();
token_buffer += c;
// the newline is not part of the token
for (;;) {
c = input_stack::peek_char();
if (c == EOF || c == '\n')
break;
input_stack::get_char();
token_buffer += char(c);
}
context_buffer = token_buffer;
return COMMAND_LINE;
}
switch (c) {
case EOF:
return EOF;
case ' ':
case '\t':
break;
case '\\':
{
int d = input_stack::peek_char();
if (d != '\n') {
context_buffer = '\\';
return '\\';
}
input_stack::get_char();
break;
}
case '#':
do {
c = input_stack::get_char();
} while (c != '\n' && c != EOF);
if (c == '\n')
context_buffer = '\n';
return c;
case '"':
context_buffer = '"';
token_buffer.clear();
for (;;) {
c = input_stack::get_char();
if (c == '\\') {
context_buffer += '\\';
c = input_stack::peek_char();
if (c == '"') {
input_stack::get_char();
token_buffer += '"';
context_buffer += '"';
}
else
token_buffer += '\\';
}
else if (c == '\n') {
error("newline in string");
break;
}
else if (c == EOF) {
error("missing `\"'");
break;
}
else if (c == '"') {
context_buffer += '"';
break;
}
else {
context_buffer += char(c);
token_buffer += char(c);
}
}
return TEXT;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
int overflow = 0;
n = 0;
for (;;) {
if (n > (INT_MAX - 9)/10) {
overflow = 1;
break;
}
n *= 10;
n += c - '0';
context_buffer += char(c);
c = input_stack::peek_char();
if (c == EOF || !csdigit(c))
break;
c = input_stack::get_char();
}
token_double = n;
if (overflow) {
for (;;) {
token_double *= 10.0;
token_double += c - '0';
context_buffer += char(c);
c = input_stack::peek_char();
if (c == EOF || !csdigit(c))
break;
c = input_stack::get_char();
}
// if somebody asks for 1000000000000th, we will silently
// give them INT_MAXth
double temp = token_double; // work around gas 1.34/sparc bug
if (token_double > INT_MAX)
n = INT_MAX;
else
n = int(temp);
}
}
switch (c) {
case 'i':
case 'I':
context_buffer += char(c);
input_stack::get_char();
return NUMBER;
case '.':
{
context_buffer += '.';
input_stack::get_char();
got_dot:
double factor = 1.0;
for (;;) {
c = input_stack::peek_char();
if (c == EOF || !csdigit(c))
break;
input_stack::get_char();
context_buffer += char(c);
factor /= 10.0;
if (c != '0')
token_double += factor*(c - '0');
}
if (c != 'e' && c != 'E') {
if (c == 'i' || c == 'I') {
context_buffer += char(c);
input_stack::get_char();
}
return NUMBER;
}
}
// fall through
case 'e':
case 'E':
{
int echar = c;
input_stack::get_char();
c = input_stack::peek_char();
int sign = '+';
if (c == '+' || c == '-') {
sign = c;
input_stack::get_char();
c = input_stack::peek_char();
if (c == EOF || !csdigit(c)) {
input_stack::push_back(sign);
input_stack::push_back(echar);
return NUMBER;
}
context_buffer += char(echar);
context_buffer += char(sign);
}
else {
if (c == EOF || !csdigit(c)) {
input_stack::push_back(echar);
return NUMBER;
}
context_buffer += char(echar);
}
input_stack::get_char();
context_buffer += char(c);
n = c - '0';
for (;;) {
c = input_stack::peek_char();
if (c == EOF || !csdigit(c))
break;
input_stack::get_char();
context_buffer += char(c);
n = n*10 + (c - '0');
}
if (sign == '-')
n = -n;
if (c == 'i' || c == 'I') {
context_buffer += char(c);
input_stack::get_char();
}
token_double *= pow(10.0, n);
return NUMBER;
}
case 'n':
input_stack::get_char();
c = input_stack::peek_char();
if (c == 'd') {
input_stack::get_char();
token_int = n;
context_buffer += "nd";
return ORDINAL;
}
input_stack::push_back('n');
return NUMBER;
case 'r':
input_stack::get_char();
c = input_stack::peek_char();
if (c == 'd') {
input_stack::get_char();
token_int = n;
context_buffer += "rd";
return ORDINAL;
}
input_stack::push_back('r');
return NUMBER;
case 't':
input_stack::get_char();
c = input_stack::peek_char();
if (c == 'h') {
input_stack::get_char();
token_int = n;
context_buffer += "th";
return ORDINAL;
}
input_stack::push_back('t');
return NUMBER;
case 's':
input_stack::get_char();
c = input_stack::peek_char();
if (c == 't') {
input_stack::get_char();
token_int = n;
context_buffer += "st";
return ORDINAL;
}
input_stack::push_back('s');
return NUMBER;
default:
return NUMBER;
}
break;
case '\'':
{
c = input_stack::peek_char();
if (c == 't') {
input_stack::get_char();
c = input_stack::peek_char();
if (c == 'h') {
input_stack::get_char();
context_buffer = "'th";
return TH;
}
else
input_stack::push_back('t');
}
context_buffer = "'";
return '\'';
}
case '.':
{
c = input_stack::peek_char();
if (c != EOF && csdigit(c)) {
n = 0;
token_double = 0.0;
context_buffer = '.';
goto got_dot;
}
return get_token_after_dot(c);
}
case '<':
c = input_stack::peek_char();
if (c == '-') {
input_stack::get_char();
c = input_stack::peek_char();
if (c == '>') {
input_stack::get_char();
context_buffer = "<->";
return DOUBLE_ARROW_HEAD;
}
context_buffer = "<-";
return LEFT_ARROW_HEAD;
}
else if (c == '=') {
input_stack::get_char();
context_buffer = "<=";
return LESSEQUAL;
}
context_buffer = "<";
return '<';
case '-':
c = input_stack::peek_char();
if (c == '>') {
input_stack::get_char();
context_buffer = "->";
return RIGHT_ARROW_HEAD;
}
context_buffer = "-";
return '-';
case '!':
c = input_stack::peek_char();
if (c == '=') {
input_stack::get_char();
context_buffer = "!=";
return NOTEQUAL;
}
context_buffer = "!";
return '!';
case '>':
c = input_stack::peek_char();
if (c == '=') {
input_stack::get_char();
context_buffer = ">=";
return GREATEREQUAL;
}
context_buffer = ">";
return '>';
case '=':
c = input_stack::peek_char();
if (c == '=') {
input_stack::get_char();
context_buffer = "==";
return EQUALEQUAL;
}
context_buffer = "=";
return '=';
case '&':
c = input_stack::peek_char();
if (c == '&') {
input_stack::get_char();
context_buffer = "&&";
return ANDAND;
}
context_buffer = "&";
return '&';
case '|':
c = input_stack::peek_char();
if (c == '|') {
input_stack::get_char();
context_buffer = "||";
return OROR;
}
context_buffer = "|";
return '|';
default:
if (c != EOF && csalpha(c)) {
token_buffer.clear();
token_buffer = c;
for (;;) {
c = input_stack::peek_char();
if (c == EOF || (!csalnum(c) && c != '_'))
break;
input_stack::get_char();
token_buffer += char(c);
}
int tok = lookup_keyword(token_buffer.contents(),
token_buffer.length());
if (tok != 0) {
context_buffer = token_buffer;
return tok;
}
char *def = 0;
if (lookup_flag) {
token_buffer += '\0';
def = macro_table.lookup(token_buffer.contents());
token_buffer.set_length(token_buffer.length() - 1);
if (def) {
if (c == '(') {
input_stack::get_char();
interpolate_macro_with_args(def);
}
else
input_stack::push(new macro_input(def));
}
}
if (!def) {
context_buffer = token_buffer;
if (csupper(token_buffer[0]))
return LABEL;
else
return VARIABLE;
}
}
else {
context_buffer = char(c);
return (unsigned char)c;
}
break;
}
}
}
