Пример #1
0
// Switch to new zone ("!zone" or "!zn"). Has to be re-entrant.
static enum eos_t PO_zone(void) {
	section_t	entry_values;// buffer for outer zone
	char*		new_title;
	bool		allocated;

	// remember everything about current structure
	entry_values = *Section_now;
	// set default values in case there is no valid title
	new_title = untitled;
	allocated = FALSE;
	// Check whether a zone title is given. If yes and it can be read,
	// get copy, remember pointer and remember to free it later on.
	if(BYTEFLAGS(GotByte) & CONTS_KEYWORD) {
		// Because we know of one character for sure,
		// there's no need to check the return value.
		Input_read_keyword();
		new_title = DynaBuf_get_copy(GlobalDynaBuf);
		allocated = TRUE;
	}
	// setup new section
	// section type is "subzone", just in case a block follows
	Section_new_zone(Section_now, "Subzone", new_title, allocated);
	if(Parse_optional_block()) {
		// Block has been parsed, so it was a SUBzone.
		Section_finalize(Section_now);// end inner zone
		*Section_now = entry_values;// restore entry values
	} else {
		// no block found, so it's a normal zone change
		Section_finalize(&entry_values);// end outer zone
		Section_now->type = type_zone;// change type to "zone"
	}
	return(ENSURE_EOS);
}
Пример #2
0
// Append to GlobalDynaBuf while characters are legal for keywords.
// Throws "missing string" error if none.
// Returns number of characters added.
int Input_append_keyword_to_global_dynabuf(void) {
	int	length	= 0;

	// add characters to buffer until an illegal one comes along
	while(BYTEFLAGS(GotByte) & CONTS_KEYWORD) {
		DYNABUF_APPEND(GlobalDynaBuf, GotByte);
		length++;
		GetByte();
	}
	if(length == 0)
		Throw_error(exception_missing_string);
	return(length);
}
Пример #3
0
// Deliver source code from current file (!) in shortened high-level format
static char get_processed_from_file(void) {
	int	from_file;

	do {
		switch(Input_now->state) {

			case INPUTSTATE_NORMAL:
			// fetch a fresh byte from the current source file
				//from_file = getc(Input_now->src.fd);
			from_file = hacked_getc(Input_now);
			// now process it
			/*FALLTHROUGH*/

			case INPUTSTATE_AGAIN:
			// Process the latest byte again. Of course, this only
			// makes sense if the loop has executed at least once,
			// otherwise the contents of from_file are undefined.
			// If the source is changed so there is a possibility
			// to enter INPUTSTATE_AGAIN mode without first having
			// defined "from_file", trouble may arise...
			Input_now->state = INPUTSTATE_NORMAL;
			// EOF must be checked first because it cannot be used
			// as an index into Byte_flags[]
			if(from_file == EOF) {
				// remember to send an end-of-file
				Input_now->state = INPUTSTATE_EOF;
				return(CHAR_EOS);// end of statement
			}
			// check whether character is special one
			// if not, everything's cool and froody, so return it
			if((BYTEFLAGS(from_file) & BYTEIS_SYNTAX) == 0)
				return((char) from_file);
			// check special characters ("0x00 TAB LF CR SPC :;}")
			switch(from_file) {

				case CHAR_TAB:// TAB character
				case ' ':
				// remember to skip all following blanks
				Input_now->state = INPUTSTATE_SKIPBLANKS;
				return(' ');

				case CHAR_LF:// LF character
				// remember to send a start-of-line
				Input_now->state = INPUTSTATE_LF;
				return(CHAR_EOS);// end of statement

				case CHAR_CR:// CR character
				// remember to check CRLF + send start-of-line
				Input_now->state = INPUTSTATE_CR;
				return(CHAR_EOS);// end of statement

				case CHAR_EOB:
				// remember to send an end-of-block
				Input_now->state = INPUTSTATE_EOB;
				return(CHAR_EOS);// end of statement

				case CHAR_STATEMENT_DELIMITER:
				// just deliver an EOS instead
				return(CHAR_EOS);// end of statement

				case CHAR_COMMENT_SEPARATOR:
				// remember to skip remainder of line
				Input_now->state = INPUTSTATE_COMMENT;
				return(CHAR_EOS);// end of statement

				default:
				// complain if byte is 0
				Throw_error("Source file contains illegal character.");
				return((char) from_file);
			}

			case INPUTSTATE_SKIPBLANKS:
			// read until non-blank, then deliver that
				do {
//				from_file = getc(Input_now->src.fd);
					from_file = hacked_getc(Input_now);
				} while((from_file == CHAR_TAB) || (from_file == ' '));
			// re-process last byte
			Input_now->state = INPUTSTATE_AGAIN;
			break;

			case INPUTSTATE_LF:
			// return start-of-line, then continue in normal mode
			Input_now->state = INPUTSTATE_NORMAL;
			return(CHAR_SOL);// new line

			case INPUTSTATE_CR:
			// return start-of-line, remember to check for LF
			Input_now->state = INPUTSTATE_SKIPLF;
			return(CHAR_SOL);// new line

			case INPUTSTATE_SKIPLF:
				from_file = hacked_getc(Input_now);
			// if LF, ignore it and fetch another byte
			// otherwise, process current byte
			if(from_file == CHAR_LF)
				Input_now->state = INPUTSTATE_NORMAL;
			else
				Input_now->state = INPUTSTATE_AGAIN;
			break;

			case INPUTSTATE_COMMENT:
			// read until end-of-line or end-of-file
			do
				from_file = hacked_getc(Input_now);
			while((from_file != EOF) && (from_file != CHAR_CR) && (from_file != CHAR_LF));
			// re-process last byte
			Input_now->state = INPUTSTATE_AGAIN;
			break;

			case INPUTSTATE_EOB:
			// deliver EOB
			Input_now->state = INPUTSTATE_NORMAL;
			return(CHAR_EOB);// end of block

			case INPUTSTATE_EOF:
			// deliver EOF
			Input_now->state = INPUTSTATE_NORMAL;
			return(CHAR_EOF);// end of file

			default:
			Bug_found("StrangeInputMode", Input_now->state);
		}
	} while(TRUE);
}