diff --git a/buildStuff.h b/buildStuff.h new file mode 100644 index 0000000..32af9d2 --- /dev/null +++ b/buildStuff.h @@ -0,0 +1,80 @@ +#ifndef BUILD_STUFF_H_ +#define BUILD_STUFF_H_ + +#include "macrossTypes.h" + +/* buildStuff1.c */ +statementType *newStatement (statementKindType kind, statementBodyType body); +statementType *buildAlignStatement (expressionType *expression); +statementType *buildAssertStatement (expressionType *condition, expressionType *message); +statementType *buildBlockStatement (expressionListType *expressionList); +statementType *buildByteStatement (expressionListType *expressionList); +statementType *buildConstrainStatement (expressionType *expression, blockType *block); +statementType *buildDbyteStatement (expressionListType *expressionList); +statementType *buildDefineStatement (stringType *name, expressionType *value); +statementType *buildDoUntilStatement (blockType *body, conditionType condition); +statementType *buildDoWhileStatement (blockType *body, conditionType condition); +statementType *buildDoStatement (blockType *body, doEndType *end); +statementType *buildExternStatement (identifierListType *identifierList); +statementType *buildFreturnStatement (expressionType *expression); +statementType *buildFunctionStatement (stringType *name, argumentDefinitionListType *arguments, blockType *body); +statementType *buildGroupStatement (blockType *block); +statementType *buildIfStatement (ifHeadType *head, ifContinuationType continuation, ifContinuationKindType continuationKind); +statementType *buildIncludeStatement (expressionType *filename); +statementType *buildInstructionStatement (opcodeTableEntryType *opcode, operandListType *operands); +statementType *buildLongStatement (expressionListType *expressionList); +statementType *buildMacroStatement (macroTableEntryType *macro, argumentDefinitionListType *arguments, blockType *body); +statementType *buildMacroInstructionStatement (macroTableEntryType *macro, operandListType *operands); +statementType *buildMdefineStatement (stringType *name, expressionType *value); +statementType *buildMdoUntilStatement (blockType *body, struct expressionTermStruct *condition); +statementType *buildMdoWhileStatement (blockType *body, expressionType *condition); +statementType *buildMdoStatement (blockType *body, mdoEndType *end); +statementType *buildMforStatement (forExpressionsType *forExpressions, blockType *body); +statementType *buildMifStatement (mifHeadType *head, mifContinuationType continuation, ifContinuationKindType continuationKind); +statementType *buildMswitchStatement (expressionType *switchExpression, caseListType *cases); +statementType *buildMvariableStatement (stringType *name, expressionListType *value, expressionType *dimension); +statementType *buildMwhileStatement (expressionType *condition, blockType *body); +statementType *buildNullStatement (void); +statementType *buildOrgStatement (expressionType *expression); +statementType *buildPerformStatement (expressionType *expression); +statementType *buildRelStatement (void); +statementType *buildStartStatement (expressionType *expression); +statementType *buildStringStatement (expressionListType *expressionList); +statementType *buildStructStatement (symbolTableEntryType *name, blockType *body); +statementType *buildTargetStatement (expressionType *expression); +statementType *buildUndefineStatement (identifierListType *identifierList); +statementType *buildVariableStatement (stringType *name, expressionListType *value, expressionType *dimension); +statementType *buildWhileStatement (conditionType condition, blockType *body); +statementType *buildWordStatement (expressionListType *expressionList); + +/* buildStuff2.c */ +caseType *buildCase (expressionListType *caseTags, blockType *caseBody); +doEndType *buildDoEnd (conditionType condition, doEndKindType kindOfDoEnd); +forExpressionsType *buildForExpressions (expressionType *initExpression, expressionType *testExpression, expressionType *incrExpression); +ifHeadType *buildIfHead (conditionType condition, blockType *block); +mdoEndType *buildMdoEnd (expressionType *condition, doEndKindType kindOfMdoEnd); +mifHeadType *buildMifHead (expressionType *condition, blockType *block); +arrayTermType *buildArrayTerm (expressionType *array, expressionType *index); +binopTermType *buildBinopTerm (binopKindType binop, expressionType *leftArgument, expressionType *rightArgument); +functionCallTermType *buildFunctionCall (stringType *functionName, operandListType *arguments); +postOpTermType *buildPostOpTerm (postOpKindType postOp, expressionType *postOpArgument); +preOpTermType *buildPreOpTerm (preOpKindType preOp, expressionType *preOpArgument); +unopTermType *buildUnopTerm (unopKindType unop, expressionType *unopArgument); +expressionTermType *buildExpressionTerm (expressionTermKindType kindOfExpressionTerm, anyOldThing *arg1, anyOldThing *arg2, anyOldThing *arg3); +macroTableEntryType *buildMacroTableEntry (stringType *name); +symbolTableEntryType *buildSymbolTableEntry (stringType *name, symbolUsageKindType usage); +codeBreakType *buildCodeBreak (codeBreakKindType kind, addressType address, int data); +reservationListType *buildReservation (addressType startAddress, int blockSize, reservationListType *nextReservation); +simpleFixupListType *buildSimpleFixupList (valueType locationToFixup, simpleFixupListType *previousList); + +/* buildStuff3.c */ +argumentListHeadType *buildArgumentList (stringType *new, argumentListHeadType *rest, bool arrayTag); +caseListHeadType *buildCaseList (caseType *new, caseListHeadType *rest); +expressionListHeadType *buildExpressionList (expressionType *new, expressionListHeadType *rest); +identifierListHeadType *buildIdentifierList (stringType *new, identifierListHeadType *rest, symbolUsageKindType usage); +labelListHeadType *buildLabelList (symbolTableEntryType *new, labelListHeadType *rest); +operandListHeadType *buildOperandList (operandType *new, operandListHeadType *rest); +selectionListHeadType *buildSelectionList (selectionListType *new, selectionListHeadType *rest); +statementListHeadType *buildStatementList (statementType *new, statementListHeadType *rest); + +#endif diff --git a/errorStuff.h b/errorStuff.h new file mode 100644 index 0000000..4381169 --- /dev/null +++ b/errorStuff.h @@ -0,0 +1,16 @@ +#ifndef ERROR_STUFF_H_ +#define ERROR_STUFF_H_ + +void puntOnError (errorType theError, ...); +void printErrorMessage (errorType theError, va_list ap); +void error (errorType theError, ...); +void verror (errorType theError, va_list ap); +void warning (errorType theError, ...); +void fatalError (errorType theError, ...); +void fatalSystemError (errorType theError, ...); +void yyerror (char *s); +char *usageString (symbolUsageKindType usageKind); +char *valueKindString (valueKindType valueKind); +char *assignmentString (assignmentKindType assignment); + +#endif diff --git a/lexer.h b/lexer.h new file mode 100644 index 0000000..a3f3031 --- /dev/null +++ b/lexer.h @@ -0,0 +1,32 @@ +#ifndef LEXER_H_ +#define LEXER_H_ + +int yylex (void); +int lexer (void); +void initializeLexDispatchTable (void); +bool isMacrossLiteralCharacter (char c); +void snarfAlphanumericString (char c, char *buffer); +int lexIdentifier (char c); +int lexNumber (char c); +int fancyAtoI (char *buffer, int base); +int digitValue (char c); +int lexLiteral (char c); +int lexCharacterConstant (void); +int getStringCharacter (FILE *input); +int lexStringConstant (void); +int lexOperator (char firstC); +char controlCharacter (char c); +char skipWhitespaceAndComments (void); +int popInputFileStack (void); +void pushInputFileStack (stringType *fileName); +void resynchronizeInput (void); +void saveLineForListing (stringType *line); +void saveEOLForListing (void); +void saveIndexForListing (statementKindType kindOfStatement, int cumulativeLineNumber); +void saveEndMifForListing (int cumulativeLineNumber); +void saveListingOff (void); +void saveListingOn (void); +char *myfgets (char *buffer, int length, FILE *stream); +int readAnotherLine (void); + +#endif diff --git a/lookups.h b/lookups.h new file mode 100644 index 0000000..e9b2a0a --- /dev/null +++ b/lookups.h @@ -0,0 +1,27 @@ +#ifndef LOOKUPS_H_ +#define LOOKUPS_H_ + +conditionType lookupConditionCode (char *s, int hashValue); +int lookupKeyword (char *s, int hashValue); +macroTableEntryType *lookupMacroName (char *s, int hashValue); +opcodeTableEntryType *lookupOpcode (char *s, int hashValue); +symbolTableEntryType *lookupOrEnterSymbol (stringType *s, symbolUsageKindType kind); +void pushSymbol (symbolTableEntryType *symbol); +void popSymbol (symbolTableEntryType *symbol); +macroTableEntryType *createMacro (stringType *macroName); +genericTableEntryType *prehashedStringLookup (char *s, genericTableEntryType **table, int hashValue); +genericTableEntryType *hashStringLookup (char *s, genericTableEntryType **table); +genericTableEntryType *hashStringEnter (genericTableEntryType *entry, genericTableEntryType **table); +int hashString (char *s); +bool strcmplc (char *s1, char *s2); +bool strcmplct (char *s1, char *s2); +void purgeSymbol (symbolTableEntryType *symbol); +void reincarnateSymbol (symbolInContextType *context, symbolUsageKindType newUsage); +void pushBinding (symbolTableEntryType *symbol, valueType *newBinding, symbolUsageKindType newUsage); +void popBinding (symbolTableEntryType *symbol); +int bindMacroArguments (argumentDefinitionListType *argumentList, operandListType *parameterList, stringType *macroName); +int bindFunctionArguments (argumentDefinitionListType *argumentList, operandListType *parameterList, stringType *functionName); +void unbindArguments (argumentDefinitionListType *argumentList, int numberToUnbind); +void unbindLocalVariables (identifierListType *identifierList); + +#endif diff --git a/macross_6502.y b/macross_6502.y index 7e0ffb1..1ae08d8 100644 --- a/macross_6502.y +++ b/macross_6502.y @@ -31,6 +31,14 @@ #include "macrossTypes.h" #include "macrossGlobals.h" +#include "buildStuff.h" +#include "errorStuff.h" +#include "lexer.h" +#include "lookups.h" +#include "operandStuff.h" +#include "parserMisc.h" +#include "semanticMisc.h" +#include "statementSemantics.h" %} @@ -119,7 +127,8 @@ eolList: EOL statementList: statement { if (statementListNestingDepth == 0) { - $$ = eatStatement($1); + eatStatement($1); + $$ = NULL; } else { $$ = buildStatementList($1, NULL); } @@ -127,7 +136,8 @@ statementList: statement | statementList EOL statement { if (statementListNestingDepth == 0) { - $$ = eatStatement($3); + eatStatement($3); + $$ = NULL; } else { $$ = buildStatementList($3, $1); } @@ -223,15 +233,21 @@ labelableStatement: ifStatement: IF _ ifHead { - $$ = buildIfStatement($3, NULL, NO_CONTINUATION); + ifContinuationType noCont; + noCont.blockUnion=NULL; + $$ = buildIfStatement($3, noCont, NO_CONTINUATION); } | IF _ ifHead elsePart { - $$ = buildIfStatement($3, $4, ELSE_CONTINUATION); + ifContinuationType cont; + cont.blockUnion=$4; + $$ = buildIfStatement($3, cont, ELSE_CONTINUATION); } | IF _ ifHead elseIf { - $$ = buildIfStatement($3, $4, ELSEIF_CONTINUATION); + ifContinuationType cont; + cont.blockUnion=$4; + $$ = buildIfStatement($3, cont, ELSEIF_CONTINUATION); } ; @@ -271,15 +287,21 @@ elseIf: ELSE _ ifStatement } | ELSEIF _ ifHead { - $$ = extractIfBody(buildIfStatement($3, NULL, NO_CONTINUATION)); + ifContinuationType noCont; + noCont.blockUnion = NULL; + $$ = extractIfBody(buildIfStatement($3, noCont, NO_CONTINUATION)); } | ELSEIF _ ifHead elsePart { - $$ = extractIfBody(buildIfStatement($3, $4, ELSE_CONTINUATION)); + ifContinuationType cont; + cont.blockUnion = $4; + $$ = extractIfBody(buildIfStatement($3, cont, ELSE_CONTINUATION)); } | ELSEIF _ ifHead elseIf { - $$ = extractIfBody(buildIfStatement($3, $4, ELSEIF_CONTINUATION)); + ifContinuationType cont; + cont.blockUnion = $4; + $$ = extractIfBody(buildIfStatement($3, cont, ELSEIF_CONTINUATION)); } ; @@ -657,15 +679,21 @@ macroDefineStatement: macroIfStatement: MIF _ mIfHead { - $$ = buildMifStatement($3, NULL, NO_CONTINUATION); + mifContinuationType noCont; + noCont.mifBlockUnion = NULL; + $$ = buildMifStatement($3, noCont, NO_CONTINUATION); } | MIF _ mIfHead mElsePart { - $$ = buildMifStatement($3, $4, ELSE_CONTINUATION); + mifContinuationType cont; + cont.mifBlockUnion = $4; + $$ = buildMifStatement($3, cont, ELSE_CONTINUATION); } | MIF _ mIfHead mElseIf { - $$ = buildMifStatement($3, $4, ELSEIF_CONTINUATION); + mifContinuationType cont; + cont.mifBlockUnion = $4; + $$ = buildMifStatement($3, cont, ELSEIF_CONTINUATION); } ; @@ -693,15 +721,21 @@ mElseIf: MELSE _ macroIfStatement } | MELSEIF _ mIfHead { - $$ = extractMifBody(buildMifStatement($3, NULL, NO_CONTINUATION)); + mifContinuationType noCont; + noCont.mifBlockUnion = NULL; + $$ = extractMifBody(buildMifStatement($3, noCont, NO_CONTINUATION)); } | MELSEIF _ mIfHead mElsePart { - $$ = extractMifBody(buildMifStatement($3, $4, ELSE_CONTINUATION)); + mifContinuationType cont; + cont.mifBlockUnion = $4; + $$ = extractMifBody(buildMifStatement($3, cont, ELSE_CONTINUATION)); } | MELSEIF _ mIfHead mElseIf { - $$ = extractMifBody(buildMifStatement($3, $4, ELSEIF_CONTINUATION)); + mifContinuationType cont; + cont.mifBlockUnion = $4; + $$ = extractMifBody(buildMifStatement($3, cont, ELSEIF_CONTINUATION)); } ; @@ -943,18 +977,18 @@ selectionList: SELECT _ Identifier array: variable '[' _ expression _ ']' { - $$ = buildExpressionTerm(ARRAY_EXPR, $1, $4); + $$ = buildExpressionTerm(ARRAY_EXPR, $1, $4, NULL); } | array '[' _ expression _ ']' { - $$ = buildExpressionTerm(ARRAY_EXPR, $1, $4); + $$ = buildExpressionTerm(ARRAY_EXPR, $1, $4, NULL); } ; variable: Identifier { $$ = buildExpressionTerm(IDENTIFIER_EXPR, lookupOrEnterSymbol($1, - unknownSymbolTag)); + unknownSymbolTag), NULL, NULL); } ; @@ -968,47 +1002,47 @@ expression: lvalue } | functionCall { - $$ = buildExpressionTerm(FUNCTION_CALL_EXPR, $1); + $$ = buildExpressionTerm(FUNCTION_CALL_EXPR, $1, NULL, NULL); } | Number { - $$ = buildExpressionTerm(NUMBER_EXPR, $1); + $$ = buildExpressionTerm(NUMBER_EXPR, $1, NULL, NULL); } | ConditionCode { - $$ = buildExpressionTerm(CONDITION_CODE_EXPR, $1); + $$ = buildExpressionTerm(CONDITION_CODE_EXPR, $1, NULL, NULL); } | HERE { - $$ = buildExpressionTerm(HERE_EXPR); + $$ = buildExpressionTerm(HERE_EXPR, NULL, NULL, NULL); } | TextString { - $$ = buildExpressionTerm(STRING_EXPR, $1); + $$ = buildExpressionTerm(STRING_EXPR, $1, NULL, NULL); } | '(' _ expression _ ')' { - $$ = buildExpressionTerm(SUBEXPRESSION_EXPR, $3); + $$ = buildExpressionTerm(SUBEXPRESSION_EXPR, $3, NULL, NULL); } | SUB _ expression %prec UNARY_MINUS { - $$ = buildExpressionTerm(UNOP_EXPR, UNARY_MINUS, $3); + $$ = buildExpressionTerm(UNOP_EXPR, UNARY_MINUS, $3, NULL); } | LOGICAL_NOT _ expression { - $$ = buildExpressionTerm(UNOP_EXPR, LOGICAL_NOT, $3); + $$ = buildExpressionTerm(UNOP_EXPR, LOGICAL_NOT, $3, NULL); } | BITWISE_NOT _ expression { - $$ = buildExpressionTerm(UNOP_EXPR, BITWISE_NOT, $3); + $$ = buildExpressionTerm(UNOP_EXPR, BITWISE_NOT, $3, NULL); } | DIV _ expression %prec LO_BYTE { - $$ = buildExpressionTerm(UNOP_EXPR, LO_BYTE, $3); + $$ = buildExpressionTerm(UNOP_EXPR, LO_BYTE, $3, NULL); } | HI_BYTE _ expression { - $$ = buildExpressionTerm(UNOP_EXPR, HI_BYTE, $3); + $$ = buildExpressionTerm(UNOP_EXPR, HI_BYTE, $3, NULL); } | expression MUL _ expression { @@ -1052,7 +1086,7 @@ expression: lvalue } | expression GREATER_THAN_OR_EQUAL_TO _ expression { - $$ = buildExpressionTerm(BINOP_EXPR, GREATER_THAN_OR_EQUAL_TO, $1,$4); + $$ = buildExpressionTerm(BINOP_EXPR, GREATER_THAN_OR_EQUAL_TO, $1, $4); } | expression EQUAL_TO _ expression { @@ -1097,19 +1131,19 @@ expression: lvalue } | lvalue INCREMENT { - $$ = buildExpressionTerm(POSTOP_EXPR, INCREMENT, $1); + $$ = buildExpressionTerm(POSTOP_EXPR, INCREMENT, $1, NULL); } | lvalue DECREMENT { - $$ = buildExpressionTerm(POSTOP_EXPR, DECREMENT, $1); + $$ = buildExpressionTerm(POSTOP_EXPR, DECREMENT, $1, NULL); } | INCREMENT _ lvalue { - $$ = buildExpressionTerm(PREOP_EXPR, INCREMENT, $3); + $$ = buildExpressionTerm(PREOP_EXPR, INCREMENT, $3, NULL); } | DECREMENT _ lvalue { - $$ = buildExpressionTerm(PREOP_EXPR, DECREMENT, $3); + $$ = buildExpressionTerm(PREOP_EXPR, DECREMENT, $3, NULL); } ; diff --git a/parserMisc.h b/parserMisc.h index 533186c..9984ce7 100644 --- a/parserMisc.h +++ b/parserMisc.h @@ -2,7 +2,7 @@ #define PARSER_MISC_H_ #include "macrossTypes.h" -statementType *addLabelToSatement(labelListType *labelList, statementType *statement); +statementType *addLabelToStatement(labelListType *labelList, statementType *statement); void botch(char *message, ...); void checkDefineAssignmentOperator(assignmentKindType assignmentOperator); void convertDefineToMDefine(statementType *defineStatement);