quakeforge/libs/gib/gib_semantics.c

551 lines
15 KiB
C
Raw Normal View History

2003-04-11 04:37:41 +00:00
/*
gib_semantics.c
GIB tree handling functions
Copyright (C) 2003 Brian Koropoff
Author: Brian Koropoff
Date: #DATE#
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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#include <string.h>
#include "QF/qtypes.h"
#include "gib_tree.h"
#include "gib_parse.h"
#include "gib_semantics.h"
2003-04-11 04:37:41 +00:00
static int
GIB_Semantic_Validate_Class (gib_tree_t * tokens)
{
gib_tree_t *a_class, *line, *cmd;
if (!tokens->next || !tokens->next->next) {
GIB_Parse_Error ("Malformed class definition; expected class "
"name, optional 'extends' and parent class, and "
"program block.", tokens->start);
return -1;
}
if (tokens->next->next->delim == ' ' && !strcmp
(tokens->next->next->str, "extends")) {
if (!tokens->next->next->next) {
GIB_Parse_Error ("Malformed class definition; "
"expected parent class after "
"\":\".", tokens->next->next->start);
return -1;
}
a_class = tokens->next->next->next->next;
} else
a_class = tokens->next->next;
if (!a_class || !a_class->children || a_class->delim != '{') {
GIB_Parse_Error ("Malformed class definition; expected "
"program block.", tokens->next->next->start);
return -1;
}
for (line = a_class->children; line; line = line->next) {
switch (line->type) {
case TREE_T_LABEL:
if (strcmp (line->str, "class") && strcmp
(line->str, "instance")) {
GIB_Parse_Error ("Malformed class "
"definition; allowed "
"labels are instance "
"and class.",
line->start);
return -1;
}
break;
case TREE_T_CMD:
cmd = line->children;
if (strcmp (cmd->str, "function")) {
GIB_Parse_Error ("Malformed class "
"definition; only "
"allowed command is "
"function.",
cmd->start);
return -1;
} else {
gib_tree_t *last;
for (last = cmd; last->next; last = last->next);
if (!cmd->next || !last || last->delim != '{' ||
!last->children) {
GIB_Parse_Error ("Malformed function "
"definition; name, "
"optional arg list, "
"program block "
"expected.",
cmd->start);
return -1;
}
}
break;
default:
GIB_Parse_Error ("Malformed class "
"definition; only commands "
"and labels allowed.",
line->start);
return -1;
break;
}
}
return 0;
}
2003-04-11 04:37:41 +00:00
static gib_tree_t *
GIB_Semantic_Normal_To_Lines (gib_tree_t * tokens, const char *program, gib_tree_flags_t flags, unsigned int start, unsigned int end)
{
gib_tree_t *mainline, *lines = 0, *embedded, *token, *temp;
/* Normal tokens */
// Create main line struct now as an anchor
lines = mainline = GIB_Tree_New (TREE_T_CMD);
for (token = tokens; token; token = token->next) {
// Normal token?
if (token->delim == ' ' || token->delim == '(') {
// Check for embedded commands/variables
embedded = GIB_Parse_Embedded (token);
if (gib_parse_error) {
GIB_Tree_Unref (&mainline);
return 0;
}
if (embedded) {
// Find end of embedded commands
for (temp = embedded; temp->next; temp = temp->next);
// Link it in
temp->next = lines;
lines = embedded;
// Mark token for processing at runtime
token->flags |= TREE_A_EMBED;
} else if (token->children)
// Mark token for processing at runtime
token->flags |= TREE_A_EMBED;
}
}
// Fill in info for primary line
mainline->str = program;
mainline->flags = flags;
mainline->start = start;
mainline->end = end;
// Check for assignment
if (tokens->next && tokens->next->delim == ' ' && !strcmp (tokens->next->str, "="))
mainline->type = TREE_T_ASSIGN;
// Check for message sending
else if (tokens->next && tokens->next->delim == ' ' && !strcmp (tokens->next->str, "->")) {
if (!tokens->next->next) {
GIB_Tree_Unref (&mainline);
GIB_Parse_Error ("Cannot send empty message.", token->next->start);
return NULL;
} else
mainline->type = TREE_T_SEND;
// Check for class definition, validate
} else if (!strcmp (tokens->str, "class") &&
GIB_Semantic_Validate_Class (tokens)) {
GIB_Tree_Unref (&mainline);
return NULL;
}
mainline->children = tokens;
2003-04-11 04:37:41 +00:00
return lines;
}
static gib_tree_t *
GIB_Semantic_Process_Conditional (gib_tree_t *tokens)
{
gib_tree_t *lines = 0, *temp, *cur, *embedded;
// Check for embeddeds in first token
lines = GIB_Parse_Embedded (tokens);
if (gib_parse_error)
return 0;
if (lines || tokens->children)
tokens->flags |= TREE_A_EMBED;
// Iterate through all tokens concatenated to the first
for (cur = tokens->next; cur && cur->flags & TREE_A_CONCAT; cur = cur->next) {
embedded = GIB_Parse_Embedded (cur);
if (gib_parse_error)
return 0;
if (embedded) {
for (temp = embedded; temp->next; temp = temp->next);
temp->next = lines;
lines = embedded;
cur->flags |= TREE_A_EMBED;
} else if (cur->children)
cur->flags |= TREE_A_EMBED;
}
return lines;
}
static gib_tree_t *
GIB_Semantic_If_To_Lines (gib_tree_t **tokens, const char *program, gib_tree_flags_t flags, gib_tree_t *end)
{
gib_tree_t *token = *tokens, *lines, *temp, **next = &lines, *conditional;
gib_tree_t *a_block;
// Sanity checking
if (flags & TREE_L_EMBED) {
GIB_Parse_Error ("if statements may not be used in embedded commands.", token->start);
return 0;
}
if (!token->next || !token->next->next) {
GIB_Parse_Error ("malformed if statement; not enough arguments", token->start);
return 0;
}
for (a_block = token->next->next; a_block->flags & TREE_A_CONCAT; a_block = a_block->next)
if (!a_block->next) {
GIB_Parse_Error ("malformed if statement; not enough arguments", token->start);
return 0;
}
if (a_block->delim != '{') {
GIB_Parse_Error ("malformed if statement; second argument is not a program block", token->next->next->start);
return 0;
}
if (a_block->next) { // Else statement?
if (a_block->next->delim != ' ' || strcmp (a_block->next->str, "else") || (a_block->next->next && a_block->next->next->flags & TREE_A_CONCAT)) {
GIB_Parse_Error ("malformed if statement; expected \"else\" for third argument", token->next->next->next->start);
return 0;
}
if (!a_block->next->next) {
GIB_Parse_Error ("malformed if statement; expected arguments after \"else\"", token->next->next->next->start);
return 0;
}
}
// Process embedded stuff on conditional argument
lines = GIB_Semantic_Process_Conditional (token->next);
if (gib_parse_error)
return 0;
if (lines) {
for (temp = lines; temp->next; temp = temp->next);
next = &temp->next;
}
// Create conditional instruction
conditional = GIB_Tree_New (TREE_T_COND);
conditional->children = token;
conditional->start = token->start;
conditional->end = token->next->end;
conditional->str = program;
conditional->flags = token->str[2] ? flags | TREE_L_NOT : flags;
// Link it in
*next = conditional;
next = &conditional->next;
// Move program block inline
*next = a_block->children;
a_block->children = 0;
// Find end of program block
for (temp = *next; temp->next; temp = temp->next);
next = &temp->next;
// Add jump to end point
*next = GIB_Tree_New (TREE_T_JUMP);
(*next)->jump = end;
conditional->jump = *next;
next = &(*next)->next;
// Is there an else statement?
if (a_block->next) {
temp = a_block->next;
token = a_block->next->next;
// Is this a program block?
if (token->delim == '{') {
// Move program block inline
*next = token->children;
token->children = 0;
*tokens = 0;
} else {
// Cut off part we don't use
temp->next = 0;
// Indicate to caller that more tokens remain
*tokens = token;
// String will get used again, make a personal copy
conditional->str = strdup (program);
}
} else
// No tokens left
*tokens = 0;
return lines;
}
static gib_tree_t *
GIB_Semantic_While_To_Lines (gib_tree_t *tokens, const char *program, gib_tree_flags_t flags)
{
gib_tree_t *lines, **next = &lines, *temp, *conditional, *endp;
gib_tree_t *a_block;
// Sanity checking
if (flags & TREE_L_EMBED) {
GIB_Parse_Error ("while statements may not be used in embedded commands", tokens->start);
return 0;
}
if (!tokens->next || !tokens->next->next) {
GIB_Parse_Error ("malformed while statement; incorrect number of arguments", tokens->start);
return 0;
}
for (a_block = tokens->next->next; a_block->flags & TREE_A_CONCAT; a_block = a_block->next)
if (!a_block->next) {
GIB_Parse_Error ("malformed while statement; incorrect number of arguments", tokens->start);
return 0;
}
if (a_block->delim != '{') {
GIB_Parse_Error ("malformed while statement; expected program block for second argument", a_block->start);
return 0;
}
// Process embedded stuff on conditional argument
lines = GIB_Semantic_Process_Conditional (tokens->next);
if (gib_parse_error)
return 0;
if (lines) {
for (temp = lines; temp->next; temp = temp->next);
next = &temp->next;
}
// Create conditional instruction
conditional = GIB_Tree_New (TREE_T_COND);
conditional->children = tokens;
conditional->start = tokens->start;
conditional->end = tokens->next->end;
conditional->str = program;
conditional->flags = flags;
// Link it in
*next = conditional;
next = &conditional->next;
// Create end point (for 'break' commands)
endp = GIB_Tree_New (TREE_T_LABEL);
2003-04-11 04:37:41 +00:00
// Move program block inline
*next = a_block->children;
a_block->children = 0;
// Find end of program block
for (temp = *next; temp->next; temp = temp->next) {
// Check for break or continue
if (!temp->jump && temp->children) {
if (!strcmp (temp->children->str, "break")) {
temp->type = TREE_T_JUMP;
temp->jump = endp;
} else if (!strcmp (temp->children->str, "continue")) {
temp->type = TREE_T_JUMP;
temp->jump = lines;
}
}
}
next = &temp->next;
// Add jump back to top of loop
temp = GIB_Tree_New (TREE_T_JUMP);
temp->jump = lines;
*next = temp;
next = &temp->next;
// Attach landing point for 'break' instructions
*next = endp;
// This is our last instruction, set it as escape for loop
conditional->jump = endp;
return lines;
}
static gib_tree_t *
GIB_Semantic_For_To_Lines (gib_tree_t *tokens, const char *program, gib_tree_flags_t flags)
{
gib_tree_t *lines = 0, **next = &lines, *temp, *endp, *forinst, *embedded;
gib_tree_t *a_in, *a_block;
// Do sanity checks
if (flags & TREE_L_EMBED) {
GIB_Parse_Error ("for statements may not be used in embedded commands.", tokens->start);
return 0;
}
if (!tokens->next) {
GIB_Parse_Error ("malformed for statement; not enough arguments.", tokens->start);
return 0;
}
for (a_in = tokens->next; a_in->delim != ' ' || strcmp (a_in->str, "in"); a_in = a_in->next) {
if (!a_in->next) {
GIB_Parse_Error ("malformed for statement; expected \"in\".", tokens->start);
return 0;
}
if (a_in->flags & TREE_A_EMBED || a_in->flags & TREE_A_EXPAND)
a_in->flags &= ~(TREE_A_EMBED | TREE_A_EXPAND);
}
if (!a_in->next) {
GIB_Parse_Error ("malformed for statement; expected arguments after \"in\".", a_in->start);
return 0;
}
for (a_block = a_in->next; a_block->next; a_block = a_block->next);
if (a_block->delim != '{') {
GIB_Parse_Error ("malformed for statement; expected program block as last argument.", a_block->start);
return 0;
}
for (a_in = a_in->next; a_in != a_block; a_in = a_in->next) {
embedded = GIB_Parse_Embedded (a_in);
if (gib_parse_error)
return 0;
if (embedded) {
for (temp = embedded; temp->next; temp = temp->next);
temp->next = lines;
lines = embedded;
a_in->flags |= TREE_A_EMBED;
} else if (a_in->children)
a_in->flags |= TREE_A_EMBED;
}
if (lines) {
for (temp = lines; temp->next; temp = temp->next);
next = &temp->next;
}
forinst = GIB_Tree_New (TREE_T_CMD);
forinst->children = tokens;
forinst->start = tokens->start;
forinst->end = a_block->start;
forinst->str = program;
forinst->flags = flags;
*next = forinst;
forinst->next = GIB_Tree_New (TREE_T_FORNEXT);
forinst = forinst->next;
next = &forinst->next;
*next = a_block->children;
a_block->children = 0;
endp = GIB_Tree_New (TREE_T_LABEL);
2003-04-11 04:37:41 +00:00
// Find end of program block
for (temp = *next; temp->next; temp = temp->next) {
// Check for break or continue
if (!temp->jump && temp->children) {
if (!strcmp (temp->children->str, "break")) {
temp->type = TREE_T_JUMP;
temp->jump = endp;
} else if (!strcmp (temp->children->str, "continue")) {
temp->type = TREE_T_JUMP;
temp->jump = forinst;
}
}
}
next = &temp->next;
*next = GIB_Tree_New (TREE_T_JUMP);
(*next)->jump = forinst;
(*next)->next = endp;
forinst->jump = endp;
return lines;
}
static gib_tree_t *
GIB_Semantic_Label_To_Lines (gib_tree_t *tokens, const char *program,
gib_tree_flags_t flags)
{
gib_tree_t *line;
char *name;
line = GIB_Tree_New (TREE_T_LABEL);
name = strdup (tokens->str);
name[strlen(name)-1] = '\0';
line->str = name;
line->flags = flags;
GIB_Tree_Unref (&tokens);
return line;
}
2003-04-11 04:37:41 +00:00
gib_tree_t *
GIB_Semantic_Tokens_To_Lines (gib_tree_t *tokens, const char *program, gib_tree_flags_t flags, unsigned int start, unsigned int end)
{
gib_tree_t *lines, **next = &lines, *temp, *endp = 0;
// If we are being weird, don't even bother trying to match special statements
if (tokens->next && tokens->next->flags & TREE_A_CONCAT)
return GIB_Semantic_Normal_To_Lines (tokens, program, flags, start, end);
// Handle if statements
if (!strcmp (tokens->str, "if") || !strcmp (tokens->str, "ifnot")) {
// Create landing pad where all program blocks in
// a chained if/else structure will jump to after
// completing so that only one block is executed.
endp = GIB_Tree_New (TREE_T_LABEL);
2003-04-11 04:37:41 +00:00
do {
// Link in output from if statement handler
*next = GIB_Semantic_If_To_Lines (&tokens, program, flags, endp);
if (gib_parse_error)
goto ERROR;
// Find end of output
for (temp = *next; temp->next; temp = temp->next);
next = &temp->next;
} while (tokens && (!strcmp (tokens->str, "if") || !strcmp (tokens->str, "ifnot")));
}
if (!tokens)
// Yes, goto is evil. See if I care.
goto DONE;
if (!strcmp (tokens->str, "while"))
*next = GIB_Semantic_While_To_Lines (tokens, program, flags);
else if (!strcmp (tokens->str, "for"))
*next = GIB_Semantic_For_To_Lines (tokens, program, flags);
else if (tokens->str[strlen(tokens->str)-1] == ':' && !tokens->next)
*next = GIB_Semantic_Label_To_Lines (tokens, program, flags);
2003-04-11 04:37:41 +00:00
else
*next = GIB_Semantic_Normal_To_Lines (tokens, program, flags, start, end);
next = &(*next)->next;
if (gib_parse_error)
goto ERROR;
DONE:
// Connect landing pad, if one exists
if (endp)
*next = endp;
return lines;
ERROR:
if (endp)
GIB_Tree_Unref (&endp);
return 0;
}