Source Code 1992 March

home *** CD-ROM | disk | FTP | other *** search

/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3182 < prev next >

Wrap

Internet Message Format | 1991-04-11 | 43.5 KB

From: bob@reed.UUCP (Bob Ankeney) Newsgroups: alt.sources Subject: PL/M to C converter Part 02/03 Message-ID: <16304@reed.UUCP> Date: 9 Apr 91 17:01:59 GMT #!/bin/sh # this is part 2 of a multipart archive # do not concatenate these parts, unpack them in order with /bin/sh # file io.c continued # CurArch=2 if test ! -r s2_seq_.tmp then echo "Please unpack part 1 first!" exit 1; fi ( read Scheck if test "$Scheck" != $CurArch then echo "Please unpack part $Scheck next!" exit 1; else exit 0; fi ) < s2_seq_.tmp || exit 1 sed 's/^X//' << 'SHAR_EOF' >> io.c X} X X/* X * Print all white space up first new-line (if any). X * Move white_space_start to point past first new-line. X */ Xout_pre_line(token) XTOKEN *token; X{ X while ((token->white_space_start < token->white_space_end) && X (*token->white_space_start != '\n')) { X out_char(*token->white_space_start); X token->white_space_start++; X } X} X X/* X * Print all white space up to but not including last new-line. X * Move white_space_start to point to last new-line. X */ Xout_pre_white(token) XTOKEN *token; X{ X char *ptr; X int length; X X for (ptr = token->white_space_end; X (ptr > token->white_space_start) && (*(ptr - 1) != '\n') ; ) X ptr--; X X if (ptr == token->white_space_start) X return; X X /* Compute length of white space */ X length = ptr - token->white_space_start - 1; X X if (length) X out_data(token->white_space_start, length); X X token->white_space_start = ptr - 1; X} X X/* X * Output token name X */ Xout_token_name(token) XTOKEN *token; X{ X if (is_a_type(token)) X out_type(token->token_type); X else X out_data(token->token_name, strlen(token->token_name)); X} X X/* X * Output white space and token name X */ Xout_token(token) XTOKEN *token; X{ X out_white_space(token); X out_token_name(token); X} X X/* X * Output guaranteed white space and token name X */ Xout_must_token(token) XTOKEN *token; X{ X out_must_white(token); X out_token_name(token); X} X X/* X * Output case converted token name X */ Xout_cvt_name(token) XTOKEN *token; X{ X char *ptr; X X for (ptr = token->token_name; *ptr; ptr++) { X if (is_a_lc_char(*ptr)) X out_char(*ptr - 32); X else X if (is_a_uc_char(*ptr)) X out_char(*ptr + 32); X else X out_char(*ptr); X } X} X X/* X * Output string X */ Xout_str(string) Xchar *string; X{ X out_data(string, strlen(string)); X} X X/* X * Output character X */ Xout_char(ch) Xchar ch; X{ X out_data(&ch, 1); X} X X/* X * Output new-line if not at start of line X */ Xout_to_start() X{ X if (last_out_ch != LF) X out_char(LF); X} X X/* X * Output type X */ Xout_type(type) Xint type; X{ X switch (type) { X X case BYTE : X#ifdef CONVERT_TYPES X out_str(TYPE_BYTE); X#else X out_str("BYTE"); X#endif X break; X X case WORD : X#ifdef CONVERT_TYPES X out_str(TYPE_WORD); X#else X out_str("WORD"); X#endif X break; X X case DWORD : X#ifdef CONVERT_TYPES X out_str(TYPE_DWORD); X#else X out_str("DWORD"); X#endif X break; X X case INTEGER : X#ifdef CONVERT_TYPES X out_str(TYPE_INTEGER); X#else X out_str("INTEGER"); X#endif X break; X X case REAL : X#ifdef CONVERT_TYPES X out_str(TYPE_REAL); X#else X out_str("REAL"); X#endif X break; X X case POINTER : X out_str(TYPE_POINTER); X break; X X default : X parse_error("Unknown type"); X } X} X X/* X * Initialize variables for I/O. X */ Xout_init() X{ X out_string = NULL; X last_out_ch = '\0'; X parsing_literal = FALSE; X} X X/* X * Output string constant of form 'WXYZ' in form: X * 'W' << 24 | 'X' << 16 | 'Y' << 8 | Z X * where len specifies the number of bytes in the string to output. X */ Xout_str_const(str_ptr, len) Xchar *str_ptr; Xint len; X{ X while (len-- && *str_ptr) { X out_char('\''); X if (*str_ptr == '\'') X out_char('\\'); X out_char(*str_ptr++); X out_char('\''); X X if (len) { X out_str(" << "); X out_str(str_shifts[len]); X if (*str_ptr) X out_str(" | "); X } X } X} X X/* X * Convert NUMERIC constant to octal constant X */ Xcvt_octal(token, octal_string) XTOKEN *token; Xchar octal_string[]; X{ X int octal; X char ch, *ptr; X X octal = 0; X octal_string[0] = '\\'; X octal_string[4] = '\0'; X X ch = *(token->token_start + token->token_length - 1); X X /* Determine base of numeric */ X if (ch == 'H') { X /* Hex */ X for (ptr = token->token_name + 2; *ptr; ptr++) { X octal *= 16; X if ((*ptr >= '0') && (*ptr <= '9')) X octal += *ptr - '0'; X else X if ((*ptr >= 'A') && (*ptr <= 'Z')) X octal += *ptr - 'A' + 10; X else X if ((*ptr >= 'a') && (*ptr <= 'z')) X octal += *ptr - 'a' + 10; X else { X parse_error("Illegal hex character"); X return; X } X } X } else X X if ((ch == 'O') || (ch == 'Q')) { X /* Octal constant */ X for (ptr = token->token_name + 1; *ptr; ptr++) { X octal *= 8; X if ((*ptr >= '0') && (*ptr <= '7')) X octal += *ptr - '0'; X else { X parse_error("Illegal decimal character"); X return; X } X } X } else { X X /* Decimal constant */ X for (ptr = token->token_name + 1; *ptr; ptr++) { X octal *= 10; X if ((*ptr >= '0') && (*ptr <= '9')) X octal += *ptr - '0'; X else { X parse_error("Illegal decimal character"); X return; X } X } X } X X X /* Generate octal constant */ X octal_string[1] = ((octal >> 6) & 3) + '0'; X octal_string[2] = ((octal >> 3) & 7) + '0'; X octal_string[3] = (octal & 7) + '0'; X} SHAR_EOF chmod 0660 io.c || echo "restore of io.c fails" sed 's/^X//' << 'SHAR_EOF' > lit.c && X /********************************************************************* X ********************************************************************* X ** ** X ** ** X ** LITERALS ** X ** ** X ** ** X ** Revision History: SCO #23 (12/11/84) ** X ** SCO #31 (02/12/86) {SCO31.DOC} ** X ** SCO #33 (06/03/86) {SCO33.DOC} ** X ** SCO #34 (10/28/86) {SCO34.DOC} ** X ** SCO #36 (07/16/86) {SCO36.DOC} ** X ** SCO #48 (03/21/87) {SCO48.DOC} ** X ** ** X ********************************************************************* X *********************************************************************/ X X X X X X#define POWER_FAIL_SENSE_LATCH 0x0080 X#define INTERRUPT_CONTROLLER_PORT_1 0x00C0 X#define INTERRUPT_CONTROLLER_PORT_2 0x00C2 X#define INSTRUCTION_WORD_1 0x13 X#define INSTRUCTION_WORD_2 0x20 X#define INSTRUCTION_WORD_3 0x01 X#define END_OF_PARITY_INTERRUPT 0x60 X#define END_OF_EXCEPTION_INTERRUPT 0x61 X#define END_OF_REFRESH_INTERRUPT 0x62 X#define END_OF_CYCLE_INTERRUPT 0x63 X#define END_OF_SHORT_INTERRUPT 0x67 X#define INTERRUPT_CONTROLLER_MASK_0 0x0F0 X#define INTERRUPT_CONTROLLER_MASK_1 0x0FC X#define INTERRUPT_CONTROLLER_MASK_2 0x0F8 X#define INTERRUPT_CONTROLLER_MASK_3 0x0F4 X#define INTERVAL_TIMER_PORT_1 0x0D2 X#define INTERVAL_TIMER_PORT_2 0x0D6 X#define CONTROL_WORD 0x74 X#define DATA_WORD_1 0x12 X#define DATA_WORD_2 0x7A X#define CONTROL_WORD_87 0x033C X#define DPM_CONTROL_WORD_87 0x0F3C X#define BIT_CONTROL_WORD_87 0x0F3C X#define INTERFACE_1_START_CODE 0x01 X#define INTERFACE_2_START_CODE 0x01 X#define HCP_NORMAL 0x00 X#define HCP_TEST_MODE 0x01 X#define HCP_ADVANCE 0x02 X#define HCP_RESET 0x03 X#define HCP_ALTITUDE_HOLD_RESET 0x04 X#define HCP_FAIL 0x07 X X#define IS = X#define VALID 0x55 X#define NO_COMPUTED_DATA 0x66 X#define FUNCTIONAL_TEST 0x99 X#define TEST_MODE 0x0AA /*{SCO36.DOC}*/ X#define FLIGHT_MODE 0x55 /*{SCO36.DOC}*/ X#define POSITIVE_BIAS 0 /*{SCO31.DOC}*/ X#define NEGATIVE_BIAS 1 /*{SCO31.DOC}*/ X#define RESET 0x0AA X#define PASS 0x55 X#define ON 0x55 X#define TO_VOR 0x55 X#define FROM_VOR 0x99 X#define ILS 0x55 /*{SCO48.DOC}*/ X#define VOR 0x0AA /*{SCO48.DOC}*/ X#define INVALID 0x0AA X#define OFF 0x0AA X#define PUSHED 0x55 X#define SET 0x55 X#define FAIL 0x0AA X#define FAILED 0x0FF X#define VMC 4 X#define IMC 5 X#define CRZ 6 X#define TOGA 7 X#define BLANK 10 X#define NEGATIVE_SIGN 11 X X#define ERROR_DISPLAY 0x5554 X#define PFM_KEY_COUNTER 0x5555 X#define PFM_TIMER 0x5556 X#define COMPUTER_FAULT 0x5557 X#define KEY1 5 X#define KEY2 4 X#define KEY3 3 X#define KEY4 2 X#define KEY5 1 X#define KEY6 0 X#define DISPLAY_GENERATOR_PORT 0x0C000 X#define DISPLAY_GENERATOR_HALT_CODE 3 X#define DISPLAY_GENERATOR_START_CODE 4 X#define DISPLAY_HALT_ENABLE_CODE 0 X#define DG_HALT 0x0005 X#define LOAD_ROTATION_ANGLE 0x0007 X#define LOAD_PRESENT_POSITION 0x0008 X#define DRAW_VECTOR 0x0009 X#define LOAD_BORDERS 0x000D X#define ZERO_DEGREE_ANGLE 0 X#define NINETY_DEGREE_ANGLE 0x4000 X#define NEG_NINETY_DEGREE_ANGLE 0x0C000 X#define ONE_EIGHTY_DEGREE_ANGLE 0x8000 X#define FIRST_HALF_OF_BUFFER 0 X#define SECOND_HALF_OF_BUFFER 750 X#define WINDOW_COMPARATOR_FAIL 0 X#define WINDOW_COMPARATOR_PASS 7 X#define TWENTY_CYCLES 20 X#define FORTY_CYCLES 40 X X#define IOS1_CODE_CHECKSUM_ERROR 0x11 /*{SCO31.DOC}*/ X#define IOS1_RAM_ERROR 0x12 /*{SCO31.DOC}*/ X#define IOS1_80186_ERROR 0x13 /*{SCO31.DOC}*/ X#define IOS1_8087_ERROR 0x14 /*{SCO31.DOC}*/ X#define IOS1_CONVERTOR_ERROR 0x15 /*{SCO31.DOC}*/ X#define IOS1_HUD_POWER_SUPPLY_ERROR 0x16 /*{SCO31.DOC}*/ X#define IOS2_CODE_CHECKSUM_ERROR 0x21 /*{SCO31.DOC}*/ X#define IOS2_RAM_ERROR 0x22 /*{SCO31.DOC}*/ X#define IOS2_80186_ERROR 0x23 /*{SCO31.DOC}*/ X#define IOS2_8087_ERROR 0x24 /*{SCO31.DOC}*/ X#define IOS2_CONVERTOR_ERROR 0x25 /*{SCO31.DOC}*/ X#define CLP_CODE_CHECKSUM_ERROR 0x31 /*{SCO31.DOC}*/ X#define CLP_RAM_ERROR 0x32 /*{SCO31.DOC}*/ X#define CLP_8086_ERROR 0x33 /*{SCO31.DOC}*/ X#define CLP_8087_ERROR 0x34 /*{SCO31.DOC}*/ X#define SM_CODE_CHECKSUM_ERROR 0x41 /*{SCO31.DOC}*/ X#define SM_RAM_ERROR 0x42 /*{SCO31.DOC}*/ X#define SM_8086_ERROR 0x43 /*{SCO31.DOC}*/ X#define SM_8087_ERROR 0x44 /*{SCO31.DOC}*/ X#define SYSTEM_MONITOR_INACTIVE 0x45 /*{SCO31.DOC}*/ X#define DISPLAY_GENERATOR_ERROR 0x51 /*{SCO31.DOC}*/ X#define SYMBOL_MISPOSITIONED_1 0x52 /*{SCO31.DOC}*/ X#define OHU_VIDEO_FAIL 0x63 /*{SCO31.DOC}*/ X#define OHU_HVPS_FAIL 0x64 /*{SCO31.DOC}*/ X#define OHU_95_OR_30_VOLT_SUPPLY_FAIL 0x65 /*{SCO31.DOC}*/ X#define SYMBOL_MISPOSITIONED_2 0x71 /*{SCO31.DOC}*/ X#define WINDOW_COMPARATOR_ERROR 0x77 /*{SCO31.DOC}*/ X#define DEU_VERTICAL_DEFLECTION_FAIL 0x7A /*{SCO31.DOC}*/ X#define DEU_HORIZONTAL_DEFLECTION_FAIL 0x7B /*{SCO31.DOC}*/ X#define DEU_DC_SUPPLY_FAIL 0x7C /*{SCO31.DOC}*/ X#define DEU_BOOST_SUPPLY_FAIL 0x7D /*{SCO31.DOC}*/ X#define DEU_DEFLECTION_SUPPLY_FAIL 0x7E /*{SCO31.DOC}*/ X#define TEST_ERROR_DISPLAY 0x88 X#define DISPLAY_GENERATOR_TEST 0x89 X#define HCP_FAILURE 0x91 /*{SCO31.DOC}*/ X#define RSU_FAILURE 0x0A1 /*{SCO34.DOC}*/ X#define COMBINER_NOT_LOCKED 0x0B1 /*{SCO33.DOC}*/ X#define EIGHTH_SECOND 3 X#define ONE_SIXTH_SECOND 3 X#define QUARTER_SECOND 5 X#define ONE_THIRD_SECOND 6 X#define HALF_SECOND 10 X#define ONE_SECOND 20 X#define ONE_POINT_FIVE_SECONDS 30 X#define TWO_SECONDS 40 X#define FIVE_SECONDS 100 X X#define HALF_PI 1.57079633F X#define PI 3.14159265F X#define TWO_PI 6.28318531F X#define TEN_KNOTS 16.9F X#define TEN_DEGREES 0.1745F X#define FIFTEEN_DEGREES 0.2618F X#define MAXIMUM_NUMBER 99999.9F X X#define FOREVER while (1) X SHAR_EOF chmod 0660 lit.c || echo "restore of lit.c fails" sed 's/^X//' << 'SHAR_EOF' > main.c && X#include <stdio.h> X#ifdef IBMPC X#include <stdlib.h> X#include <sys\stat.h> X#else X#include <sys/types.h> X#include <sys/stat.h> X#endif X#include <fcntl.h> X#include "misc.h" X#include "defs.h" X#include "cvt.h" X#include "struct.h" X#include "tokens.h" X#include "tkn_defs.h" X Xchar *text_buffer, *text_ptr; Xint line_count; Xchar *line_ptr; Xchar current_file_name[128]; Xchar out_file_name[128]; Xint at_decl_count; Xchar at_decl_list[MAX_AT_DECLS][MAX_TOKEN_LENGTH]; XFILE *ofd; X Xint file_depth; X XFILE *fopen(); X X/* X * Get list of AT declaration variables for EXTERNAL declaration checks X */ Xget_at_decl() X{ X int i, fd; X char ch; X X at_decl_count = 0; X if ((fd = open("at_decl.cvt", O_RDONLY)) == -1) X /* Not found */ X return; X X while (read(fd, &ch, 1) == 1) { X i = 0; X if (!is_a_char(ch)) { X fprintf(stderr, "Illegal identifier in line %d at_decl.cvt\n", X at_decl_count + 1); X exit(1); X } X do { X#ifdef CONVERT_CASE X if (is_a_uc_char(ch)) X /* Convert to lower case */ X ch += 32; X else X if (is_a_lc_char(ch)) X /* Convert to upper case */ X ch -= 32; X#endif X at_decl_list[at_decl_count][i++] = ch; X if (read(fd, &ch, 1) != 1) { X fprintf(stderr, "Unexpected EOF in at_decl.cvt\n"); X exit(1); X } X } while ((ch != '\n') && (ch != ' ')); X X at_decl_list[at_decl_count++][i] = '\0'; X } X} X X/* X * Open specified file, init options, and parse. X */ Xcvt_file(file_name) Xchar *file_name; X{ X int fd, nr; X struct stat file_stat; X TOKEN token, fname_token, token_module, token_do; X int token_class; X char *tmp_text_buffer, *tmp_text_ptr, *tmp_line_ptr; X char *tmp_ptr; X int tmp_line_count; X char tmp_file_name[128]; X X char *get_mem(); X X /* Is this the first file? */ X if (file_depth) { X /* No - save old text pointers */ X tmp_text_buffer = text_buffer; X tmp_text_ptr = text_ptr; X tmp_line_ptr = line_ptr; X tmp_line_count = line_count; X (void) strcpy(tmp_file_name, current_file_name); X } X X /* Save file name */ X (void) strcpy(current_file_name, file_name); X X /* Open file */ X if ((fd = open(file_name, O_RDONLY)) == -1) { X (void) fprintf(stderr, "Cannot open input file %s", file_name); X perror(""); X exit(1); X } X X /* Get length */ X if (fstat(fd, &file_stat)) { X perror("Cannot stat input file"); X exit(1); X } X X /* Allocate that much RAM */ X text_buffer = get_mem((unsigned int) file_stat.st_size + 1); X X /* Read file */ X if ((nr = read(fd, text_buffer, (int) file_stat.st_size)) == -1) { X perror("Cannot read input file"); X exit(1); X } X X /* Insert End-of-file Mark */ X text_buffer[nr] = '\0'; X (void) close(fd); X X /* Init pointers */ X text_ptr = text_buffer; X line_ptr = text_ptr; X line_count = 1; X X /* Init I/O */ X out_init(); X X /* Start with initial context using file name */ X (void) strcpy(fname_token.token_name, file_name); X fname_token.token_class = IDENTIFIER; X new_context(MODULE, &fname_token); X X /* Is this the first file? */ X if (file_depth++ == 0) { X /* Yes - open output file */ X if ((ofd = fopen(out_file_name, "w")) == NULL) { X (void) fprintf(stderr, "Cannot create output file %s", X out_file_name); X exit(1); X } X X /* Check for module name */ X token_class = get_token(&token_module); X out_pre_white(&token_module); X tmp_ptr = token_module.token_start; X if ((token_class == IDENTIFIER) && X /* Maybe got module name - Check for : */ X (get_token(&token) == LABEL) && X /* Check for DO; */ X ((get_token(&token_do) == RESERVED) && X (token_do.token_type == DO)) && X (get_token(&token) == END_OF_LINE)) { X X /* Got module header */ X out_pre_white(&token_do); X X /* Parse to END [<module name>] */ X parse_till_end(&token); X out_white_space(&token); X X token_class = get_token(&token); X if (token_class == IDENTIFIER) { X out_pre_white(&token); X token_class = get_token(&token); X } X X /* Should be at end of line */ X if (token_class != END_OF_LINE) { X parse_error("';' expected"); X } X X /* Should be at end of file */ X if (get_token(&token) != END_OF_FILE) { X parse_error("End of file expected"); X } X out_white_space(&token); X } else { X out_pre_white(&token_do); X parse_warning("Module name expected"); X text_ptr = tmp_ptr; X parse_file(); X } X } else X parse_file(); X X free(text_buffer); X X /* Was this the first file? */ X if (--file_depth) { X /* No - restore old text pointers */ X text_buffer = tmp_text_buffer; X text_ptr = tmp_text_ptr; X line_ptr = tmp_line_ptr; X line_count = tmp_line_count; X (void) strcpy(current_file_name, tmp_file_name); X } else X exit(0); X} X X/* X * Open file and init options X */ Xmain(argc, argv) Xint argc; Xchar *argv[]; X{ X int i; X char ch; X X if (argc != 2) { X (void) fprintf(stderr, "usage: %s filename\n", argv[0]); X exit(1); X } X X /* Search for a '.' in filename */ X for (i = strlen(argv[1]) - 1; i; i--) { X ch = argv[1][i]; X if ((ch == '.') || (ch == '/') || (ch == '\\')) X break; X } X X if (ch != '.') X i = strlen(argv[1]); X X /* Append a '.c' */ X (void) strncpy(out_file_name, argv[1], i); X out_file_name[i] = '\0'; X (void) strcat(out_file_name, ".c"); X (void) printf("Output to: %s\n", out_file_name); X X /* Get AT declaration list */ X get_at_decl(); X X /* Init context */ X init_context(); X X file_depth = 0; X X /* Parse main file */ X cvt_file(argv[1]); X} SHAR_EOF chmod 0660 main.c || echo "restore of main.c fails" sed 's/^X//' << 'SHAR_EOF' > makefile && X# Makefile for Unix X XSRCS = convert.c \ X parse.c \ X declare.c \ X decl_out.c \ X control.c \ X io.c \ X token.c \ X context.c \ X mem.c \ X error.c \ X version.c \ X main.c X XOBJS = convert.o \ X parse.o \ X declare.o \ X decl_out.o \ X control.o \ X io.o \ X token.o \ X context.o \ X mem.o \ X error.o \ X version.o \ X main.o X XLNKS = convert parse declare decl_out control io token context mem error version main X XTOKEN_HDRS = misc.h defs.h struct.h cvt.h cvt_id.h tokens.h XHDRS = $(TOKEN_HDRS) tkn_defs.h tkn_ext.h X XOPTS = -c -O X Xplm2c: $(OBJS) X $(CC) -o plm2c $(OBJS) X Xconvert.o: convert.c $(TOKEN_HDRS) X $(CC) $(OPTS) convert.c X Xparse.o: parse.c $(TOKEN_HDRS) cvt_id.h X $(CC) $(OPTS) parse.c X Xdeclare.o: declare.c $(TOKEN_HDRS) X $(CC) $(OPTS) declare.c X Xcontrol.o: control.c $(TOKEN_HDRS) tkn_ext.h X $(CC) $(OPTS) control.c X Xdecl_out.o: decl_out.c $(TOKEN_HDRS) X $(CC) $(OPTS) decl_out.c X Xio.o: io.c $(TOKEN_HDRS) tkn_ext.h X $(CC) $(OPTS) io.c X Xtoken.o: token.c $(TOKEN_HDRS) tkn_ext.h X $(CC) $(OPTS) token.c X Xcontext.o: context.c $(TOKEN_HDRS) X $(CC) $(OPTS) context.c X Xmem.o: mem.c $(TOKEN_HDRS) X $(CC) $(OPTS) mem.c X Xerror.o: error.c $(TOKEN_HDRS) X $(CC) $(OPTS) error.c X Xversion.o: version.c X $(CC) $(OPTS) version.c X Xmain.o: main.c $(TOKEN_HDRS) tkn_defs.h X $(CC) $(OPTS) main.c X Xbackup: X cp $(HDRS) Makefile bak X cp $(SRCS) bak X Xlint: X lint $(SRCS) X Xclean: X rm -f $(OBJS) SHAR_EOF chmod 0660 makefile || echo "restore of makefile fails" sed 's/^X//' << 'SHAR_EOF' > makefile.ibm && X# Makefile for IBM-PC MSDOS X XSRCS = convert.c \ X parse.c \ X declare.c \ X decl_out.c \ X control.c \ X io.c \ X token.c \ X context.c \ X mem.c \ X error.c \ X version.c \ X main.c X XOBJS = convert.obj \ X parse.obj \ X declare.obj \ X decl_out.obj \ X control.obj \ X io.obj \ X token.obj \ X context.obj \ X mem.obj \ X error.obj \ X version.obj \ X main.obj X XLNKS = convert parse declare decl_out control io token context mem error version main X XTOKEN_HDRS = misc.h defs.h struct.h cvt.h cvt_id.h tokens.h XHDRS = $(TOKEN_HDRS) tkn_defs.h tkn_ext.h X XMDL = m XOPTS = -c -N -v -DIBMPC -m$(MDL) X Xplm2c: $(OBJS) X tlink /c /v c:\tc\lib\c0$(MDL) $(LNKS), plm2c, plm2c, c:\tc\lib\c$(MDL) X Xconvert.obj: convert.c $(TOKEN_HDRS) X tcc $(OPTS) convert X Xparse.obj: parse.c $(TOKEN_HDRS) cvt_id.h X tcc $(OPTS) parse X Xdeclare.obj: declare.c $(TOKEN_HDRS) X tcc $(OPTS) declare X Xcontrol.obj: control.c $(TOKEN_HDRS) tkn_ext.h X tcc $(OPTS) control X Xdecl_out.obj: decl_out.c $(TOKEN_HDRS) X tcc $(OPTS) decl_out X Xio.obj: io.c $(TOKEN_HDRS) tkn_ext.h X tcc $(OPTS) io X Xtoken.obj: token.c $(TOKEN_HDRS) tkn_ext.h X tcc $(OPTS) token X Xcontext.obj: context.c $(TOKEN_HDRS) X tcc $(OPTS) context X Xmem.obj: mem.c $(TOKEN_HDRS) X tcc $(OPTS) mem X Xerror.obj: error.c $(TOKEN_HDRS) X tcc $(OPTS) error X Xversion.obj: version.c X tcc $(OPTS) version X Xmain.obj: main.c $(TOKEN_HDRS) tkn_defs.h X tcc $(OPTS) main X Xbackup: X cp $(HDRS) Makefile bak X cp $(SRCS) bak X Xfloppy: X cp $(HDRS) makefile a: X cp $(SRCS) a: X Xlint: X lint $(SRCS) X SHAR_EOF chmod 0660 makefile.ibm || echo "restore of makefile.ibm fails" sed 's/^X//' << 'SHAR_EOF' > mem.c && X#ifdef IBMPC X#include <alloc.h> X#endif X#include "misc.h" X#include "defs.h" X#include "cvt.h" X#include "struct.h" X X/* X * Memory allocation and deallocation routines. X */ X X/* X * Allocate memory X */ Xchar *get_mem(size) Xunsigned int size; X{ X char *malloc_ptr; X void *malloc(); X X if ((malloc_ptr = (char *)malloc(size)) == NULL) { X parse_error("Out of memory"); X exit(1); X } X return malloc_ptr; X} X X/* X * Generate a new context. X */ Xget_context_ptr(context) XCONTEXT **context; X{ X *context = (CONTEXT *) get_mem(sizeof(CONTEXT)); X (*context)->decl_head = NULL; X (*context)->next_context = NULL; X} X X/* X * Malloc memory for a TOKEN. X */ Xget_token_ptr(token) XTOKEN **token; X{ X *token = (TOKEN *) get_mem(sizeof(TOKEN)); X} X X/* X * Malloc memory for a DECL_ID. X */ Xget_var_ptr(var) XDECL_ID **var; X{ X *var = (DECL_ID *) get_mem(sizeof(DECL_ID)); X (*var)->name = NULL; X (*var)->based_name = NULL; X (*var)->next_var = NULL; X (*var)->is_ext_at = FALSE; X} X X/* X * Free a linked list of variables. X */ Xfree_var_list(list_ptr) XDECL_ID *list_ptr; X{ X DECL_ID *next_ptr; X X while (list_ptr) { X if (list_ptr->name) X free( (char *) list_ptr->name); X if (list_ptr->based_name) X free( (char *) list_ptr->based_name); X next_ptr = list_ptr->next_var; X free((char *) list_ptr); X list_ptr = next_ptr; X } X} X X/* X * Malloc space for a DECL_MEMBER structure and return pointer. X */ Xget_element_ptr(element) XDECL_MEMBER **element; X{ X DECL_MEMBER *el_ptr; X X /* Malloc space for element */ X el_ptr = (DECL_MEMBER *) get_mem(sizeof(DECL_MEMBER)); X X /* Init pointers */ X el_ptr->name_list = NULL; X el_ptr->literal = NULL; X#ifdef PARSE_LITERALS X el_ptr->literal_token = NULL; X#endif X el_ptr->array_bound = NULL; X el_ptr->type = NULL; X el_ptr->struct_list = NULL; X el_ptr->at_ptr = NULL; X el_ptr->init_ptr = NULL; X el_ptr->next_member = NULL; X X el_ptr->attributes = NONE; X el_ptr->initialization = NONE; X X *element = el_ptr; X} X X/* X * Free a DECL_MEMBER list. X */ Xfree_decl_list(element) XDECL_MEMBER *element; X{ X DECL_MEMBER *el_ptr; X X while (element) { X if (element->name_list) X free_var_list(element->name_list); X if (element->literal) X free((char *) element->literal); X if (element->array_bound) X free((char *) element->array_bound); X if (element->type) X free((char *) element->type); X if (element->struct_list) X free_decl_list(element->struct_list); X if (element->at_ptr) X free(element->at_ptr); X X el_ptr = element->next_member; X free((char *) element); X element = el_ptr; X } X} X X/* X * Malloc space for a procedure parameter X */ Xget_param_ptr(param) XPARAM_LIST **param; X{ X *param = (PARAM_LIST *) get_mem(sizeof(PARAM_LIST)); X (*param)->next_param = NULL; X} X X/* X * Free parameter list X */ Xfree_param_list(param_list) XPARAM_LIST *param_list; X{ X PARAM_LIST *param_ptr; X X while (param_list) { X param_ptr = param_list->next_param; X free((char *) param_list); X param_list = param_ptr; X } X} X X/* X * Malloc space for a DECLARE statement X */ Xget_decl_ptr(decl) XDECL **decl; X{ X *decl = (DECL *) get_mem(sizeof(DECL)); X (*decl)->decl_list = NULL; X (*decl)->next_decl = NULL; X} X X/* X * Free DECL list X */ Xfree_decl(decl_list) XDECL *decl_list; X{ X DECL *decl_ptr; X X while (decl_list) { X decl_ptr = decl_list->next_decl; X#ifdef FREE_DECL_TOKEN X if (decl_list->decl_token) X free((char *) decl_list->decl_token); X#endif X if (decl_list->decl_list) X free_decl_list(decl_list->decl_list); X free((char *) decl_list); X decl_list = decl_ptr; X } X} X X SHAR_EOF chmod 0660 mem.c || echo "restore of mem.c fails" sed 's/^X//' << 'SHAR_EOF' > misc.h && X/* X * Miscellaneous defines X */ Xtypedef unsigned char BYTE; Xtypedef unsigned char BOOLEAN; X X X#ifndef TRUE X#define TRUE 1 X#endif X X#ifndef FALSE X#define FALSE 0 X#endif X X#ifndef NULL X#define NULL 0 X#endif X X/* X * White space characters X */ X#define SPACE ' ' X#define TAB 9 X#define CR 13 X#define LF 10 X X/* X * Useful defines X */ X#define is_a_uc_char(char) ((char >= 'A') && (char <= 'Z')) X#define is_a_lc_char(char) ((char >= 'a') && (char <= 'z')) X#define is_a_char(char) (((char & 0x5F) >= 'A') && ((char & 0x5F) <= 'Z')) X#define is_a_digit(char) ((char >= '0') && (char <= '9')) X X#define is_a_type(token) ((token->token_class == RESERVED) && \ X (token->token_type >= BYTE) && (token->token_type <= REAL)) X X#define is_white(ch) ((ch == ' ') || (ch == TAB)) X X#define NONE 0 X Xchar *strcat(), *strncat(), *strcpy(), *strncpy(); X#ifdef IBMPC Xint sprintf(); X#endif SHAR_EOF chmod 0660 misc.h || echo "restore of misc.h fails" sed 's/^X//' << 'SHAR_EOF' > parse.c && X#include <stdio.h> X#ifdef IBMPC X#include <stdlib.h> X#endif X#include "misc.h" X#include "defs.h" X#include "cvt.h" X#include "struct.h" X#include "cvt_id.h" X#include "tokens.h" X Xextern char *text_buffer, *text_ptr; Xextern int line_count; Xextern char *out_string; X X/* X * Parse a procedure parameter list. X * Return head of linked list of parameters. X */ Xget_param_list(param_head) XPARAM_LIST **param_head; X{ X PARAM_LIST *list_ptr, *param_ptr; X int token_class; X TOKEN sep_token; X X *param_head = NULL; X list_ptr = NULL; X X do { X get_param_ptr(¶m_ptr); X if (*param_head == NULL) X *param_head = param_ptr; X if (list_ptr) X list_ptr->next_param = param_ptr; X list_ptr = param_ptr; X token_class = get_token(¶m_ptr->param); X if (token_class != IDENTIFIER) { X parse_error("Identifier expected"); X free_param_list(*param_head); X } X /* Get ',' or ')' */ X token_class = get_token(&sep_token); X } while (token_class == COMMA); X X if (token_class != RIGHT_PAREN) { X parse_error("')' expected"); X free_param_list(*param_head); X } X} X X/* X * Parse parameter list. X * Parse DECLARE statements until all parameters in param_list X * have been found. Split declare statements into those used in X * param_list and those not. Return pointers to head of both X * DECL_MEMBER lists. X */ Xparse_param_list(param_list, decl_list, extra_decl_list) XPARAM_LIST *param_list; XDECL **decl_list, **extra_decl_list; X{ X DECL *extra_decl, *extra_decl_ptr; X DECL *list, *list_ptr; X DECL_MEMBER *extra_list_ptr; X DECL_MEMBER *el_ptr, *last_el_ptr, *next_el_ptr; X DECL_MEMBER *extra_el_ptr; X int token_class; X TOKEN *decl_token; X DECL_ID *var_ptr, *last_var_ptr, *next_var_ptr; X DECL_ID *extra_last_var_ptr; X PARAM_LIST *param_ptr, *last_param; X X *decl_list = NULL; X *extra_decl_list = NULL; X /* Pointer to next DECL_MEMBER in decl_ptr */ X list_ptr = NULL; X /* Pointer to next DECL in extra_decl_list */ X extra_decl_ptr = NULL; X X while (param_list) { X /* Get declaration */ X get_token_ptr(&decl_token); X token_class = get_token(decl_token); X if ((token_class != RESERVED) || X (decl_token->token_type != DECLARE)) { X parse_error("DECLARE expected"); X free((char *) decl_token); X return; X } X /* Get declaration list */ X get_decl_ptr(&list); X get_decl_list(list); X list->decl_token = decl_token; X X /* Points to start of extra declaration list */ X extra_list_ptr = NULL; X X /* Pointer to previous el_ptr */ X last_el_ptr = NULL; X X /* Check each element of the DECLARE statement */ X el_ptr = list->decl_list; X while (el_ptr) { X X /* Point to next member */ X next_el_ptr = el_ptr->next_member; X X /* Pointer to next DECL_MEMBER in extra_decl_ptr */ X extra_el_ptr = NULL; X X /* Points to last variable in variable list */ X last_var_ptr = NULL; X /* Contains not found variables in name_list */ X extra_last_var_ptr = NULL; X X /* Check each variable in name list */ X for (var_ptr = el_ptr->name_list; var_ptr; ) { X /* Point to following var_ptr */ X next_var_ptr = var_ptr->next_var; X X /* Is this variable in param list? */ X last_param = NULL; X for (param_ptr = param_list; param_ptr; X param_ptr = param_ptr->next_param) { X if (!strcmp(param_ptr->param.token_name, X var_ptr->name->token_name)) X break; X else X last_param = param_ptr; X } X X if (param_ptr) { X X /* Variable found */ X /* Remove from parameter list */ X if (last_param) X last_param->next_param = param_ptr->next_param; X else X param_list = param_ptr->next_param; X X free((char *) param_ptr); X last_var_ptr = var_ptr; X } else { X/* X * Variable not found - Add to extra variable list X */ X if (extra_el_ptr == NULL) { X/* X * Create new element and copy DECLARE info X */ X get_element_ptr(&extra_el_ptr); X element_copy(el_ptr, extra_el_ptr); X extra_last_var_ptr = NULL; X/* X * Link new extra element into extra_list_ptr X */ X if (extra_list_ptr) { X extra_list_ptr->next_member = extra_el_ptr; X } else { X/* X * Create new extra declaration X */ X get_decl_ptr(&extra_decl); X X /* Point to DECLARE token */ X extra_decl->decl_token = X list->decl_token; X extra_decl->decl_list = extra_el_ptr; X/* X * Link new extra declaration into extra_decl_list X */ X if (extra_decl_ptr) X extra_decl_ptr->next_decl = extra_decl; X else X *extra_decl_list = extra_decl; X X extra_decl_ptr = extra_decl; X } X extra_list_ptr = extra_el_ptr; X } X X /* Add var_ptr to extra list */ X if (extra_last_var_ptr) X extra_last_var_ptr->next_var = var_ptr; X else X extra_list_ptr->name_list = var_ptr; X X extra_last_var_ptr = var_ptr; X X /* Remove from DECLARE list */ X if (last_var_ptr) X last_var_ptr->next_var = next_var_ptr; X else X el_ptr->name_list = next_var_ptr; X X var_ptr->next_var = NULL; X } X X var_ptr = next_var_ptr; X } X X/* X * Check for empty name list X */ X if (el_ptr->name_list == NULL) { X/* X * Empty name list - unlink and discard element from declaration list X */ X if (last_el_ptr) X last_el_ptr->next_member = next_el_ptr; X else X list->decl_list = next_el_ptr; X X el_ptr->next_member = NULL; X free((char *) el_ptr); X } else X last_el_ptr = el_ptr; X X el_ptr = next_el_ptr; X } X X /* Save found items in decl_list */ X if (list->decl_list->name_list) { X if (*decl_list) X list_ptr->next_decl = list; X else X *decl_list = list; X list_ptr = list; X } else X free((char *) list); X X } X} X X/* X * Parse until desired token type appears X */ Xparse_till(type, token) Xint type; XTOKEN *token; X{ X while (get_token(token) != type) X out_token(token); X} X X/* X * Parse until END statement X */ Xparse_till_end(token) XTOKEN *token; X{ X int token_class; X X while (1) { X token_class = get_token(token); X X if (token_class == END_OF_FILE) { X parse_error("Premature end-of-file"); X exit(1); X } X X if ((token_class == RESERVED) && (token->token_type == END)) X return; X X parse_statement(token); X } X} X X/* X * Parse through END statement X */ Xparse_to_end() X{ X TOKEN token; X X parse_till_end(&token); X parse_statement(&token); X} X X/* X * Check for end of line (';') X */ Xcheck_eol() X{ X TOKEN token; X X if (get_token(&token) != END_OF_LINE) X parse_error("';' expected"); X else X out_token(&token); X} X X/* X * Parse simple variable and return variable token and following token. X * Passed with initial identifier in token. X * Returns with next_token terminating variable. X * Handles [ .<identifier> ] ... X */ Xparse_simple_variable(token, next_token) XTOKEN *token, *next_token; X{ X int token_class; X X while (1) { X token_class = get_token(next_token); X if (token_class != PERIOD) X return token_class; X X /* Process .<identifier> */ X token_class = get_token(next_token); X if (token_class != IDENTIFIER) { X parse_error("Illegal identifier"); X return ERROR; X } X /* Add .<identifier> to original token name */ X (void) strcat(token->token_name, "."); X (void) strcat(token->token_name, next_token->token_name); X /* Parse for additional member */ X return parse_simple_variable(token, next_token); X } X} X X/* X * Parse variable identifier. If pointer, output (*ident) else X * If variable has BASED attribute, output (*based_name). X * Otherwise, output ident. X */ Xout_ident(ident, decl, decl_id) XTOKEN *ident; XDECL_MEMBER *decl; XDECL_ID *decl_id; X{ X if (decl->at_ptr || decl_id->is_ext_at) { X out_white_space(ident); X out_str("(*"); X out_token_name(ident); X out_char(')'); X } else X X if (decl_id->based_name) { X out_white_space(ident); X out_str("(**"); X out_token_name(decl_id->name); X out_char(')'); X } else X out_token(ident); X} X X/* X * Parse variable name or structure element and output appropriate tokens. X * Passed with identifier in token, and declaration for token in decl. X * Returns with token terminating variable. X * Handles <member> { [ ( <expression> ) ] [ .<identifier> ] } X */ Xparse_member(token, decl, decl_id) XTOKEN *token; XDECL_MEMBER *decl; XDECL_ID *decl_id; X{ X int token_class; X TOKEN member; X DECL_MEMBER *var_decl; X DECL_ID *var_decl_id; X X /* Check for literal */ X if (decl->literal) { X /* Yes - output case converted literal */ X out_white_space(token); X out_cvt_name(token); X /* Return next token */ X token_class = get_token(token); X return token_class; X } X X token_copy(token, &member); X X token_class = get_token(token); X X /* Check for array subscript */ X if (decl->array_bound) { X out_ident(&member, decl, decl_id); X X if (token_class == LEFT_PAREN) { X /* Convert to open square bracket */ X token->token_name[0] = '['; X out_token(token); X X /* Parse expression to right parenthesis */ X token_class = parse_expression(token); X if (token_class != RIGHT_PAREN) { X parse_error("')' expected"); X return ERROR; X } X X /* Convert to close square bracket */ X token->token_name[0] = ']'; X out_token(token); X X token_class = get_token(token); X } X } X X /* Check for .<identifier> */ X if ((decl->type->token_type == STRUCTURE) && (token_class == PERIOD)) { X X if (decl->array_bound) X /* Already printed identifier */ X out_token(token); X else { X if (decl->at_ptr || decl_id->based_name) { X/* X * --- Note: Does not handle BASED AT variables! X */ X /* Print 'member->' */ X out_token(&member); X out_str("->"); X } else { X /* Print 'member.' */ X out_ident(&member, decl, decl_id); X out_token(token); X } X } X X token_class = get_token(token); X if (token_class != IDENTIFIER) { X parse_error("Illegal structure member"); X return ERROR; X } X X /* Find variable in list */ X if (!find_list_symbol(token, decl->struct_list, X &var_decl, &var_decl_id)) { X parse_error("Undefined structure member"); X return ERROR; X } X X /* Parse this member now */ X token_class = parse_member(token, var_decl, var_decl_id); X } else X if (decl->array_bound == NULL) X out_ident(&member, decl, decl_id); X X return token_class; X} X X/* X * Parse variable and output appropriate tokens. X * Passed with initial identifier in token. X * Returns with token terminating variable. X * Handles { [ ( <expression> ) ] [ .<identifier> ] } ... X */ Xparse_variable(token, var_decl, var_decl_id) XTOKEN *token; XDECL_MEMBER **var_decl; XDECL_ID **var_decl_id; X{ X if (!find_symbol(token, var_decl, var_decl_id)) { X parse_error("Undefined variable"); X return ERROR; X } X X return parse_member(token, *var_decl, *var_decl_id); X} X X/* X * See if token is in cvt_list. X * If found, return pointer to conversion string. X */ Xcheck_cvt_id(token, cvt_id, cvt_string) XTOKEN *token; XCVT_ID *cvt_id; Xchar **cvt_string; X{ X /* Check each string in cvt_id */ X while (*(cvt_id->id_name)) { X if (!strcmp(token->token_name, cvt_id->id_name)) { X /* Found match - return new string */ X *cvt_string = cvt_id->new_id; X return TRUE; X } X X cvt_id++; X } X X return FALSE; X} X X/* X * Parse function call X */ Xparse_function(token) XTOKEN *token; X{ X int token_class; X BOOLEAN left_shift, right_shift; X char *new_func; X DECL_MEMBER *decl_ptr; X DECL_ID *decl_id; X X /* Function call - check for SHL or SHR */ X out_white_space(token); X left_shift = !strcmp(token->token_name, "shl") || X !strcmp(token->token_name, "SHL"); X right_shift = !strcmp(token->token_name, "shr") || X !strcmp(token->token_name, "SHR"); X if (left_shift || right_shift) { X /* SHL(expr, expr) or SHR(expr, expr) */ X /* Check for '(' */ X token_class = get_token(token); X if (token_class != LEFT_PAREN) { X parse_error("'(' expected"); X return ERROR; X } X out_token(token); X X /* Output first expression */ X out_char('('); X token_class = parse_expression(token); X if (token_class != COMMA) { X parse_error("',' expected"); X return ERROR; X } X X out_str(left_shift ? ") << (" : ") >> ("); X X /* Output second expression */ X token_class = parse_expression(token); X if (token_class != RIGHT_PAREN) { X parse_error("Missing ')'"); X return ERROR; X } X out_char(')'); X out_token(token); X } else { X X /* Check for a type cast function */ X if (check_cvt_id(token, &cast_functions[0], &new_func)) { X /* Convert to a cast */ X out_char('('); X out_str(new_func); X out_str(") "); X } else X X /* Check for a function conversion */ X if (check_cvt_id(token, &cvt_functions[0], &new_func)) { X /* Convert to desired function */ X out_str(new_func); X } else { X X /* Output function name */ X out_token_name(token); X X /* Check for parameter list */ X if (find_symbol(token, &decl_ptr, &decl_id)) { X if (decl_ptr->type->token_type != PROCEDURE) { X parse_error("Illegal function call"); X return ERROR; X } X if (decl_ptr->initialization != DATA) { X /* No param list */ X token_class = get_token(token); X return token_class; X } X } X } X X /* Check for parameter list */ X token_class = get_token(token); X if (token_class != LEFT_PAREN) { X parse_warning("Parameter list expected"); X return token_class; X } X out_token(token); X X /* Parse to closing right paren */ X do { X token_class = parse_expression(token); X out_token(token); X } while (token_class == COMMA); X X if (token_class != RIGHT_PAREN) { X parse_error("Missing ')'"); X return ERROR; X } X } X /* Return token following function */ X token_class = get_token(token); X return token_class; X} X X/* X * Parse expression and output appropriate tokens. X * Return token at end of expression. X */ Xparse_expression(token) XTOKEN *token; X{ X int token_class; X int i, last_class, temp_class; X DECL_MEMBER *id_type; X DECL_ID *id_id; X char *new_id; X char string_const[MAX_TOKEN_LENGTH], octal_const[5]; X X last_class = OPERATOR; X X token_class = get_token(token); X X while (1) { X X switch (token_class) { X X case LEFT_PAREN : X if (last_class != OPERATOR) { X parse_error("Missing operator"); X return ERROR; X } X X /* Sub-expression */ X out_token(token); X /* Parse to closing right paren */ X token_class = parse_expression(token); X if (token_class != RIGHT_PAREN) { X parse_error("Missing ')'"); X return ERROR; X } X X out_token(token); X break; X X case RIGHT_PAREN : X return token_class; X X case OPERATOR : X out_white_space(token); X if (token->token_type == EQUAL) X /* Make it a '==' */ X out_str("=="); X else X X /* Check for address operator '@' or '.' */ X if ((token->token_type == AT_OP) || X (token->token_type == PERIOD)) { X token_class = get_token(token); X if (token_class == IDENTIFIER) { X /* Make it a '&' */ X out_char('&'); X X /* See if it's a function reference */ X if (find_symbol(token, &id_type, &id_id) && X (id_type->type->token_type != PROCEDURE)) { X /* Variable - parse it */ X temp_class = parse_member(token, id_type, id_id); X } else { X X /* Function call - Check for */ X /* a function conversion */ X if (check_cvt_id(token, &cvt_functions[0], &new_id)) X /* Convert to desired function */ X out_str(new_id); X else X /* Function call - output name */ X out_token_name(token); X X temp_class = get_token(token); X } X } else X X if (token_class == LEFT_PAREN) { X /* Constant list - convert to string */ X out_char('"'); X string_const[0] = '\0'; X X do { X token_class = get_token(token); X if (token_class == STRING) X (void) strcat(string_const, token->token_name); X else X if (token_class == NUMERIC) { X cvt_octal(token, octal_const); X (void) strcat(string_const, octal_const); X } else { X parse_error("Illegal constant"); X return ERROR; X } X X token_class = get_token(token); X } while (token_class == COMMA); X X if (token_class != RIGHT_PAREN) { X parse_error("')' expected"); X return ERROR; X } X X i = strlen(string_const); X if ((i >= 4) && X (!strcmp(string_const + i - 4, "\\000"))) X /* Discard trailing null */ X string_const[i - 4] = '\0'; X out_str(string_const); X out_char('"'); X } else { X parse_error("Illegal operator"); X return ERROR; X } X } else X X out_token_name(token); X break; X X case IDENTIFIER : X /* Check for identifier conversion */ X if (check_cvt_id(token, &cvt_identifiers[0], &new_id)) { X out_white_space(token); X out_str(new_id); X temp_class = get_token(token); X } else X X /* See if variable in context */ X if (find_symbol(token, &id_type, &id_id) && X (id_type->type->token_type != PROCEDURE)) { X /* Variable - parse it */ X temp_class = parse_member(token, id_type, id_id); X } else X X /* Function call - parse it */ X temp_class = parse_function(token); X break; X X case NUMERIC : X out_token(token); X break; X X case STRING : X out_white_space(token); X /* Convert to a numeric constant */ X if (token->token_length > 4) { X parse_error("Illegal string constant"); X return ERROR; X } X X if (token->token_length > 1) X out_char('('); X X out_str_const(token->token_name, token->token_length); X X if (token->token_length > 1) X out_char(')'); X break; X X default : X /* Must not be part of an expression! */ X return token_class; X } X X last_class = token_class; X X token_class = (last_class == IDENTIFIER) ? X temp_class : get_token(token); X } X} X X/* X * DO statement X * Handles DO;, DO CASE, DO WHILE, and iterative DO X */ Xparse_do(first_token) XTOKEN *first_token; X{ X TOKEN token; X int token_class; X int case_line; X char case_statement[MAX_TOKEN_LENGTH]; X char case_output[MAX_CASE_STATEMENT_SIZE]; X char var_string[MAX_TOKEN_LENGTH]; X char *temp_out_string, *temp_out_string1; X DECL_MEMBER *var_decl; X DECL_ID *var_decl_id; X X /* Create new context */ X new_context(DO, (TOKEN *) NULL); X X out_white_space(first_token); X X /* Determine what kind of DO statement */ X token_class = get_token(&token); X X switch (token_class) { X X case END_OF_LINE : X /* DO; */ X out_white_space(&token); X out_char('{'); /* } for dumb vi */ X parse_to_end(); X break; X X case IDENTIFIER : X /* DO counter = start TO limit BY step */ X out_str("for"); X out_must_white(&token); X out_char('('); X X /* Put full variable in var_string */ X var_string[0] = '\0'; X temp_out_string = out_string; X out_string = var_string; X token_class = parse_variable(&token, &var_decl, &var_decl_id); SHAR_EOF echo "End of part 2, continue with part 3" echo "3" > s2_seq_.tmp exit 0