mirror of
https://github.com/shagr4th/droid48
synced 2024-12-26 21:58:12 +01:00
574 lines
18 KiB
C
574 lines
18 KiB
C
/*
|
|
* This file is part of x48, an emulator of the HP-48sx Calculator.
|
|
* Copyright (C) 1994 Eddie C. Dost (ecd@dressler.de)
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
/* $Log: small.h,v $
|
|
* Revision 1.5 1995/01/11 18:20:01 ecd
|
|
* major update to support HP48 G/GX
|
|
*
|
|
* Revision 1.4 1994/12/07 20:16:41 ecd
|
|
* completed small font
|
|
*
|
|
* Revision 1.4 1994/12/07 20:16:41 ecd
|
|
* completed small font
|
|
*
|
|
* Revision 1.3 1994/11/02 14:51:27 ecd
|
|
* minor changes
|
|
*
|
|
* Revision 1.2 1994/10/06 16:28:03 ecd
|
|
* changed char to unsigned
|
|
*
|
|
* Revision 1.1 1994/09/13 15:05:11 ecd
|
|
* Initial revision
|
|
*
|
|
*
|
|
* $Id: small.h,v 1.5 1995/01/11 18:20:01 ecd Exp ecd $
|
|
*/
|
|
|
|
#ifndef _SMALL_H
|
|
#define _SMALL_H 1
|
|
|
|
#define small_ascent 8
|
|
#define small_descent 4
|
|
|
|
#define blank_width 4
|
|
#define blank_height 7
|
|
static unsigned char blank_bits[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
|
|
|
#define hash_width 5
|
|
#define hash_height 7
|
|
static unsigned char hash_bits[] = {
|
|
0x00, 0x0a, 0x1f, 0x0a, 0x0a, 0x1f, 0x0a};
|
|
|
|
#define lbrace_width 3
|
|
#define lbrace_height 7
|
|
static unsigned char lbrace_bits[] = {
|
|
0x04, 0x02, 0x01, 0x01, 0x01, 0x02, 0x04};
|
|
|
|
#define rbrace_width 3
|
|
#define rbrace_height 7
|
|
static unsigned char rbrace_bits[] = {
|
|
0x01, 0x02, 0x04, 0x04, 0x04, 0x02, 0x01};
|
|
|
|
#define comma_width 3
|
|
#define comma_height 7
|
|
static unsigned char comma_bits[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x03};
|
|
|
|
#define slash_width 3
|
|
#define slash_height 7
|
|
static unsigned char slash_bits[] = {
|
|
0x04, 0x04, 0x02, 0x02, 0x02, 0x01, 0x01};
|
|
|
|
#define two_width 5
|
|
#define two_height 7
|
|
static unsigned char two_bits[] = {
|
|
0x0e, 0x11, 0x10, 0x08, 0x04, 0x02, 0x1f};
|
|
|
|
#define three_width 5
|
|
#define three_height 7
|
|
static unsigned char three_bits[] = {
|
|
0x0e, 0x11, 0x10, 0x0c, 0x10, 0x11, 0x0e};
|
|
|
|
#define small_colon_width 2
|
|
#define small_colon_height 7
|
|
static unsigned char small_colon_bits[] = {
|
|
0x00, 0x03, 0x03, 0x00, 0x03, 0x03, 0x00};
|
|
|
|
#define A_width 5
|
|
#define A_height 7
|
|
static unsigned char A_bits[] = {
|
|
0x0e, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11};
|
|
|
|
#define B_width 5
|
|
#define B_height 7
|
|
static unsigned char B_bits[] = {
|
|
0x0f, 0x11, 0x11, 0x0f, 0x11, 0x11, 0x0f};
|
|
|
|
#define C_width 5
|
|
#define C_height 7
|
|
static unsigned char C_bits[] = {
|
|
0x0e, 0x11, 0x01, 0x01, 0x01, 0x11, 0x0e};
|
|
|
|
#define D_width 5
|
|
#define D_height 7
|
|
static unsigned char D_bits[] = {
|
|
0x0f, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0f};
|
|
|
|
#define E_width 5
|
|
#define E_height 7
|
|
static unsigned char E_bits[] = {
|
|
0x1f, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x1f};
|
|
|
|
#define F_width 5
|
|
#define F_height 7
|
|
static unsigned char F_bits[] = {
|
|
0x1f, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x01};
|
|
|
|
#define G_width 5
|
|
#define G_height 7
|
|
static unsigned char G_bits[] = {
|
|
0x0e, 0x11, 0x01, 0x01, 0x19, 0x11, 0x0e};
|
|
|
|
#define H_width 5
|
|
#define H_height 7
|
|
static unsigned char H_bits[] = {
|
|
0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11};
|
|
|
|
#define I_width 1
|
|
#define I_height 7
|
|
static unsigned char I_bits[] = {
|
|
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
|
|
|
|
#define J_width 4
|
|
#define J_height 7
|
|
static unsigned char J_bits[] = {
|
|
0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x06};
|
|
|
|
#define K_width 5
|
|
#define K_height 7
|
|
static unsigned char K_bits[] = {
|
|
0x11, 0x09, 0x05, 0x03, 0x05, 0x09, 0x11};
|
|
|
|
#define L_width 4
|
|
#define L_height 7
|
|
static unsigned char L_bits[] = {
|
|
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0f};
|
|
|
|
#define M_width 5
|
|
#define M_height 7
|
|
static unsigned char M_bits[] = {
|
|
0x11, 0x1b, 0x15, 0x11, 0x11, 0x11, 0x11};
|
|
|
|
#define N_width 5
|
|
#define N_height 7
|
|
static unsigned char N_bits[] = {
|
|
0x11, 0x11, 0x13, 0x15, 0x19, 0x11, 0x11};
|
|
|
|
#define O_width 5
|
|
#define O_height 7
|
|
static unsigned char O_bits[] = {
|
|
0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e};
|
|
|
|
#define P_width 5
|
|
#define P_height 7
|
|
static unsigned char P_bits[] = {
|
|
0x0f, 0x11, 0x11, 0x0f, 0x01, 0x01, 0x01};
|
|
|
|
#define Q_width 5
|
|
#define Q_height 7
|
|
static unsigned char Q_bits[] = {
|
|
0x0e, 0x11, 0x11, 0x11, 0x15, 0x09, 0x16};
|
|
|
|
#define R_width 5
|
|
#define R_height 7
|
|
static unsigned char R_bits[] = {
|
|
0x0f, 0x11, 0x11, 0x0f, 0x05, 0x09, 0x11};
|
|
|
|
#define S_width 5
|
|
#define S_height 7
|
|
static unsigned char S_bits[] = {
|
|
0x0e, 0x11, 0x01, 0x0e, 0x10, 0x11, 0x0e};
|
|
|
|
#define T_width 5
|
|
#define T_height 7
|
|
static unsigned char T_bits[] = {
|
|
0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04};
|
|
|
|
#define U_width 5
|
|
#define U_height 7
|
|
static unsigned char U_bits[] = {
|
|
0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e};
|
|
|
|
#define V_width 5
|
|
#define V_height 7
|
|
static unsigned char V_bits[] = {
|
|
0x11, 0x11, 0x11, 0x11, 0x0a, 0x0a, 0x04};
|
|
|
|
#define W_width 5
|
|
#define W_height 7
|
|
static unsigned char W_bits[] = {
|
|
0x11, 0x11, 0x11, 0x11, 0x15, 0x1b, 0x11};
|
|
|
|
#define X_width 5
|
|
#define X_height 7
|
|
static unsigned char X_bits[] = {
|
|
0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11};
|
|
|
|
#define Y_width 5
|
|
#define Y_height 7
|
|
static unsigned char Y_bits[] = {
|
|
0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04};
|
|
|
|
#define Z_width 5
|
|
#define Z_height 7
|
|
static unsigned char Z_bits[] = {
|
|
0x1f, 0x10, 0x08, 0x04, 0x02, 0x01, 0x1f};
|
|
|
|
#define lbracket_width 3
|
|
#define lbracket_height 7
|
|
static unsigned char lbracket_bits[] = {
|
|
0x07, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07};
|
|
|
|
#define rbracket_width 3
|
|
#define rbracket_height 7
|
|
static unsigned char rbracket_bits[] = {
|
|
0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x07};
|
|
|
|
#define arrow_width 7
|
|
#define arrow_height 7
|
|
static unsigned char arrow_bits[] = {
|
|
0x00, 0x08, 0x18, 0x3f, 0x18, 0x08, 0x00};
|
|
|
|
#define diff_width 5
|
|
#define diff_height 7
|
|
static unsigned char diff_bits[] = {
|
|
0x0e, 0x10, 0x10, 0x1e, 0x11, 0x11, 0x0e};
|
|
|
|
#define integral_width 5
|
|
#define integral_height 8
|
|
static unsigned char integral_bits[] = {
|
|
0x0c, 0x12, 0x02, 0x04, 0x04, 0x08, 0x09, 0x06};
|
|
|
|
#define sigma_width 6
|
|
#define sigma_height 9
|
|
static unsigned char sigma_bits[] = {
|
|
0x3f, 0x21, 0x02, 0x04, 0x08, 0x04, 0x02, 0x21, 0x3f};
|
|
|
|
#define sqr_width 11
|
|
#define sqr_height 10
|
|
static unsigned char sqr_bits[] = {
|
|
0x00, 0x03, 0x80, 0x04, 0x00, 0x04, 0x00, 0x02, 0x26, 0x01, 0x94, 0x07,
|
|
0x08, 0x00, 0x14, 0x00, 0x53, 0x00, 0x21, 0x00};
|
|
|
|
#define root_width 18
|
|
#define root_height 13
|
|
static unsigned char root_bits[] = {
|
|
0x26, 0x00, 0x00, 0x14, 0x00, 0x00, 0x08, 0xfe, 0x03, 0x14, 0x02, 0x02,
|
|
0x53, 0x02, 0x00, 0x21, 0x99, 0x00, 0x00, 0x91, 0x00, 0x10, 0x91, 0x00,
|
|
0xa0, 0x50, 0x00, 0xc0, 0x60, 0x00, 0x80, 0x20, 0x00, 0x00, 0x14, 0x00,
|
|
0x00, 0x0c, 0x00};
|
|
|
|
#define pow10_width 13
|
|
#define pow10_height 9
|
|
static unsigned char pow10_bits[] = {
|
|
0x00, 0x12, 0x00, 0x0c, 0x32, 0x04, 0x4b, 0x0a, 0x4a, 0x09, 0x4a, 0x00,
|
|
0x4a, 0x00, 0x4a, 0x00, 0x32, 0x00};
|
|
|
|
#define exp_width 11
|
|
#define exp_height 9
|
|
static unsigned char exp_bits[] = {
|
|
0x80, 0x04, 0x00, 0x03, 0x00, 0x01, 0x8c, 0x02, 0x52, 0x02, 0x09, 0x00,
|
|
0x07, 0x00, 0x21, 0x00, 0x1e, 0x00};
|
|
|
|
#define under_width 6
|
|
#define under_height 7
|
|
static unsigned char under_bits[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f};
|
|
|
|
#define prog_width 16
|
|
#define prog_height 7
|
|
static unsigned char prog_bits[] = {
|
|
0x48, 0x12, 0x24, 0x24, 0x12, 0x48, 0x09, 0x90, 0x12, 0x48, 0x24, 0x24,
|
|
0x48, 0x12};
|
|
|
|
#define string_width 10
|
|
#define string_height 7
|
|
static unsigned char string_bits[] = {
|
|
0x85, 0x02, 0x85, 0x02, 0x85, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00};
|
|
|
|
#define equal_width 5
|
|
#define equal_height 7
|
|
static unsigned char equal_bits[] = {
|
|
0x00, 0x1f, 0x00, 0x00, 0x1f, 0x00, 0x00};
|
|
|
|
#define nl_width 8
|
|
#define nl_height 7
|
|
static unsigned char nl_bits[] = {
|
|
0x00, 0x84, 0x86, 0xff, 0x06, 0x04, 0x00};
|
|
|
|
#define pi_width 6
|
|
#define pi_height 7
|
|
static unsigned char pi_bits[] = {
|
|
0x20, 0x1f, 0x12, 0x12, 0x12, 0x12, 0x12};
|
|
|
|
#define angle_width 8
|
|
#define angle_height 7
|
|
static unsigned char angle_bits[] = {
|
|
0x40, 0x20, 0x10, 0x28, 0x44, 0x42, 0xff};
|
|
|
|
#define lcurly_width 5
|
|
#define lcurly_height 7
|
|
static unsigned char lcurly_bits[] = {
|
|
0x18, 0x04, 0x04, 0x02, 0x04, 0x04, 0x18};
|
|
|
|
#define rcurly_width 5
|
|
#define rcurly_height 7
|
|
static unsigned char rcurly_bits[] = {
|
|
0x03, 0x04, 0x04, 0x08, 0x04, 0x04, 0x03};
|
|
|
|
#define sqr_gx_width 11
|
|
#define sqr_gx_height 13
|
|
static unsigned char sqr_gx_bits[] = {
|
|
0x00, 0x03, 0x80, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x80, 0x07,
|
|
0x00, 0x00, 0x66, 0x00, 0x14, 0x00, 0x08, 0x00, 0x14, 0x00, 0x53, 0x00,
|
|
0x21, 0x00};
|
|
|
|
#define root_gx_width 18
|
|
#define root_gx_height 15
|
|
static unsigned char root_gx_bits[] = {
|
|
0x66, 0x00, 0x00, 0x14, 0x00, 0x00, 0x08, 0x00, 0x00, 0x14, 0x00, 0x00,
|
|
0x53, 0xfe, 0x03, 0x21, 0x02, 0x02, 0x00, 0x02, 0x00, 0x00, 0x99, 0x00,
|
|
0x00, 0x91, 0x00, 0x10, 0x91, 0x00, 0xa0, 0x50, 0x00, 0xc0, 0x60, 0x00,
|
|
0x80, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00, 0x0c, 0x00};
|
|
|
|
#define pow10_gx_width 13
|
|
#define pow10_gx_height 12
|
|
static unsigned char pow10_gx_bits[] = {
|
|
0x00, 0x12, 0x00, 0x0c, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x09, 0x32, 0x00,
|
|
0x4b, 0x00, 0x4a, 0x00, 0x4a, 0x00, 0x4a, 0x00, 0x4a, 0x00, 0x32, 0x00};
|
|
|
|
#define exp_gx_width 11
|
|
#define exp_gx_height 11
|
|
static unsigned char exp_gx_bits[] = {
|
|
0x80, 0x04, 0x00, 0x03, 0x00, 0x01, 0x80, 0x02, 0x40, 0x02, 0x0c, 0x00,
|
|
0x12, 0x00, 0x09, 0x00, 0x07, 0x00, 0x21, 0x00, 0x1e, 0x00};
|
|
|
|
#define parens_gx_width 20
|
|
#define parens_gx_height 12
|
|
static unsigned char parens_gx_bits[] = {
|
|
0x0c, 0x00, 0x03, 0x06, 0x00, 0x06, 0x06, 0x00, 0x06, 0x03, 0x00, 0x0c,
|
|
0x03, 0x00, 0x0c, 0x03, 0x00, 0x0c, 0x03, 0x00, 0x0c, 0x03, 0x00, 0x0c,
|
|
0x03, 0x00, 0x0c, 0x06, 0x00, 0x06, 0x06, 0x00, 0x06, 0x0c, 0x00, 0x03};
|
|
|
|
#define hash_gx_width 8
|
|
#define hash_gx_height 12
|
|
static unsigned char hash_gx_bits[] = {
|
|
0x00, 0x00, 0x48, 0x48, 0xfe, 0x24, 0x24, 0x7f, 0x12, 0x12, 0x00, 0x00};
|
|
|
|
#define bracket_gx_width 12
|
|
#define bracket_gx_height 12
|
|
static unsigned char bracket_gx_bits[] = {
|
|
0x0f, 0x0f, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c,
|
|
0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x03, 0x0c, 0x0f, 0x0f};
|
|
|
|
#define under_gx_width 10
|
|
#define under_gx_height 12
|
|
static unsigned char under_gx_bits[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0xff, 0x03};
|
|
|
|
#define prog_gx_width 24
|
|
#define prog_gx_height 12
|
|
static unsigned char prog_gx_bits[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc3, 0x18,
|
|
0x8c, 0x81, 0x31, 0xc6, 0x00, 0x63, 0x63, 0x00, 0xc6, 0xc6, 0x00, 0x63,
|
|
0x8c, 0x81, 0x31, 0x18, 0xc3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
|
|
|
#define quote_gx_width 12
|
|
#define quote_gx_height 12
|
|
static unsigned char quote_gx_bits[] = {
|
|
0x05, 0x0a, 0x05, 0x0a, 0x05, 0x0a, 0x05, 0x0a, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
|
|
|
#define curly_gx_width 14
|
|
#define curly_gx_height 12
|
|
static unsigned char curly_gx_bits[] = {
|
|
0x0c, 0x0c, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x03, 0x30,
|
|
0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x06, 0x18, 0x0c, 0x0c};
|
|
|
|
#define colon_gx_width 8
|
|
#define colon_gx_height 12
|
|
static unsigned char colon_gx_bits[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0x00, 0x00, 0xc3, 0xc3, 0x00};
|
|
|
|
#define angle_gx_width 12
|
|
#define angle_gx_height 12
|
|
static unsigned char angle_gx_bits[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x01, 0xc0, 0x00, 0xe0, 0x01,
|
|
0xb0, 0x03, 0x18, 0x03, 0x0c, 0x03, 0x06, 0x03, 0xff, 0x0f, 0xff, 0x0f};
|
|
|
|
#define pi_gx_width 10
|
|
#define pi_gx_height 12
|
|
static unsigned char pi_gx_bits[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xfe, 0x03, 0xff, 0x01,
|
|
0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00};
|
|
|
|
#define nl_gx_width 18
|
|
#define nl_gx_height 12
|
|
static unsigned char nl_gx_bits[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x00, 0x03, 0xf0, 0x00, 0x03,
|
|
0xfc, 0x00, 0x03, 0xff, 0xff, 0x03, 0xff, 0xff, 0x03, 0xfc, 0x00, 0x00,
|
|
0xf0, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
|
|
|
#define comma_gx_width 3
|
|
#define comma_gx_height 12
|
|
static unsigned char comma_gx_bits[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x04, 0x04, 0x02};
|
|
|
|
#define arrow_gx_width 18
|
|
#define arrow_gx_height 12
|
|
static unsigned char arrow_gx_bits[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x3c, 0x00,
|
|
0x00, 0xfc, 0x00, 0xff, 0xff, 0x03, 0xff, 0xff, 0x03, 0x00, 0xfc, 0x00,
|
|
0x00, 0x3c, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
|
|
|
#define equal_gx_width 8
|
|
#define equal_gx_height 12
|
|
static unsigned char equal_gx_bits[] = {
|
|
0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00};
|
|
|
|
typedef struct letter_t {
|
|
unsigned int w, h;
|
|
unsigned char *bits;
|
|
} letter_t;
|
|
|
|
letter_t small_font[] = {
|
|
{ 0, 0, 0 },
|
|
{ nl_gx_width, nl_gx_height, nl_gx_bits }, /* \001 == \n gx */
|
|
{ comma_gx_width, comma_gx_height, comma_gx_bits }, /* \002 == comma gx */
|
|
{ arrow_gx_width, arrow_gx_height, arrow_gx_bits }, /* \003 == \-> gx */
|
|
{ equal_gx_width, equal_gx_height, equal_gx_bits }, /* \004 == equal gx */
|
|
{ pi_gx_width, pi_gx_height, pi_gx_bits }, /* \005 == pi gx */
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 }, /* # 16 */
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ blank_width, blank_height, blank_bits }, /* # 32 */
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ hash_width, hash_height, hash_bits },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ lbrace_width, lbrace_height, lbrace_bits },
|
|
{ rbrace_width, rbrace_height, rbrace_bits },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ comma_width, comma_height, comma_bits },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ slash_width, slash_height, slash_bits },
|
|
{ 0, 0, 0 }, /* # 48 */
|
|
{ 0, 0, 0 },
|
|
{ two_width, two_height, two_bits },
|
|
{ three_width, three_height, three_bits },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ small_colon_width, small_colon_height, small_colon_bits },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ equal_width, equal_height, equal_bits },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 }, /* # 64 */
|
|
{ A_width, A_height, A_bits },
|
|
{ B_width, B_height, B_bits },
|
|
{ C_width, C_height, C_bits },
|
|
{ D_width, D_height, D_bits },
|
|
{ E_width, E_height, E_bits },
|
|
{ F_width, F_height, F_bits },
|
|
{ G_width, G_height, G_bits },
|
|
{ H_width, H_height, H_bits },
|
|
{ I_width, I_height, I_bits },
|
|
{ J_width, J_height, J_bits },
|
|
{ K_width, K_height, K_bits },
|
|
{ L_width, L_height, L_bits },
|
|
{ M_width, M_height, M_bits },
|
|
{ N_width, N_height, N_bits },
|
|
{ O_width, O_height, O_bits },
|
|
{ P_width, P_height, P_bits }, /* # 80 */
|
|
{ Q_width, Q_height, Q_bits },
|
|
{ R_width, R_height, R_bits },
|
|
{ S_width, S_height, S_bits },
|
|
{ T_width, T_height, T_bits },
|
|
{ U_width, U_height, U_bits },
|
|
{ V_width, V_height, V_bits },
|
|
{ W_width, W_height, W_bits },
|
|
{ X_width, X_height, X_bits },
|
|
{ Y_width, Y_height, Y_bits },
|
|
{ Z_width, Z_height, Z_bits },
|
|
{ lbracket_width, lbracket_height, lbracket_bits },
|
|
{ 0, 0, 0 },
|
|
{ rbracket_width, rbracket_height, rbracket_bits },
|
|
{ 0, 0, 0 },
|
|
{ under_width, under_height, under_bits },
|
|
{ 0, 0, 0 }, /* # 96 */
|
|
{ arrow_width, arrow_height, arrow_bits }, /* a == left arrow */
|
|
{ diff_width, diff_height, diff_bits }, /* b == differential */
|
|
{ integral_width, integral_height, integral_bits }, /* c == integral */
|
|
{ sigma_width, sigma_height, sigma_bits }, /* d == sigma */
|
|
{ sqr_width, sqr_height, sqr_bits }, /* e == sqr */
|
|
{ root_width, root_height, root_bits }, /* f == root */
|
|
{ pow10_width, pow10_height, pow10_bits }, /* g == pow10 */
|
|
{ exp_width, exp_height, exp_bits }, /* h == exp */
|
|
{ prog_width, prog_height, prog_bits }, /* i == << >> */
|
|
{ string_width, string_height, string_bits }, /* j == " " */
|
|
{ nl_width, nl_height, nl_bits }, /* k == New Line */
|
|
{ pi_width, pi_height, pi_bits }, /* l == pi */
|
|
{ angle_width, angle_height, angle_bits }, /* m == angle */
|
|
{ sqr_gx_width, sqr_gx_height, sqr_gx_bits }, /* n == sqr gx */
|
|
{ root_gx_width, root_gx_height, root_gx_bits }, /* o == root gx */
|
|
{ pow10_gx_width, pow10_gx_height, pow10_gx_bits }, /* p == pow10 gx */
|
|
{ exp_gx_width, exp_gx_height, exp_gx_bits }, /* q == exp gx */
|
|
{ parens_gx_width, parens_gx_height, parens_gx_bits },/* r == ( ) gx */
|
|
{ hash_gx_width, hash_gx_height, hash_gx_bits }, /* s == # gx */
|
|
{ bracket_gx_width, bracket_gx_height, bracket_gx_bits }, /* t == [] gx */
|
|
{ under_gx_width, under_gx_height, under_gx_bits }, /* u == _ gx */
|
|
{ prog_gx_width, prog_gx_height, prog_gx_bits }, /* v == << >> gx */
|
|
{ quote_gx_width, quote_gx_height, quote_gx_bits }, /* w == " " gx */
|
|
{ curly_gx_width, curly_gx_height, curly_gx_bits }, /* x == {} gx */
|
|
{ colon_gx_width, colon_gx_height, colon_gx_bits }, /* y == :: gx */
|
|
{ angle_gx_width, angle_gx_height, angle_gx_bits }, /* z == angle gx */
|
|
{ lcurly_width, lcurly_height, lcurly_bits },
|
|
{ 0, 0, 0 },
|
|
{ rcurly_width, rcurly_height, rcurly_bits },
|
|
{ 0, 0, 0 },
|
|
{ 0, 0, 0 }
|
|
};
|
|
|
|
#endif /* !_SMALL_H */
|