Return to gas2masm.c CVS log

Up to [Quake] / quakeworld / gas2masm

Annotation of quakeworld/gas2masm/gas2masm.c, revision 1.1

1.1     ! root        1: /*
        !             2: Copyright (C) 1996-1997 Id Software, Inc.
        !             3: 
        !             4: This program is free software; you can redistribute it and/or
        !             5: modify it under the terms of the GNU General Public License
        !             6: as published by the Free Software Foundation; either version 2
        !             7: of the License, or (at your option) any later version.
        !             8: 
        !             9: This program is distributed in the hope that it will be useful,
        !            10: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
        !            12: 
        !            13: See the GNU General Public License for more details.
        !            14: 
        !            15: You should have received a copy of the GNU General Public License
        !            16: along with this program; if not, write to the Free Software
        !            17: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
        !            18: 
        !            19: */
        !            20: //
        !            21: // gas to MASM source code converter
        !            22: //
        !            23: 
        !            24: #include <stdio.h>
        !            25: #include <stdlib.h>
        !            26: #include <string.h>
        !            27: 
        !            28: #define MAX_TOKENS                     100
        !            29: #define MAX_TOKEN_LENGTH       1024
        !            30: #define LF                                     0x0A
        !            31: 
        !            32: typedef enum {NOT_WHITESPACE, WHITESPACE, TOKEN_AVAILABLE, LINE_DONE, FILE_DONE, PARSED_OKAY} tokenstat;
        !            33: typedef enum {NOSEG, DATASEG, TEXTSEG} segtype;
        !            34: 
        !            35: int            tokennum;
        !            36: int            inline, outline;
        !            37: 
        !            38: char   *token;
        !            39: char   tokens[MAX_TOKENS][MAX_TOKEN_LENGTH+1];
        !            40: 
        !            41: segtype        currentseg = NOSEG;
        !            42: 
        !            43: typedef struct {
        !            44:        char    *text;
        !            45:        char    *emit;
        !            46:        int             numtokens;
        !            47:        void    (*parsefunc) (void);
        !            48: } parsefield;
        !            49: 
        !            50: 
        !            51: void errorexit (void);
        !            52: 
        !            53: 
        !            54: //==============================================
        !            55: 
        !            56: typedef struct {
        !            57:        char    *text;
        !            58:        char    *emit;
        !            59:        int             len;
        !            60: } regdesc;
        !            61: 
        !            62: regdesc        reglist[] = {
        !            63:        {"%eax", "eax", 4},
        !            64:        {"%ebx", "ebx", 4},
        !            65:        {"%ecx", "ecx", 4},
        !            66:        {"%edx", "edx", 4},
        !            67:        {"%esi", "esi", 4},
        !            68:        {"%edi", "edi", 4},
        !            69:        {"%ebp", "ebp", 4},
        !            70:        {"%esp", "esp", 4},
        !            71:        {"%ax", "ax", 3},
        !            72:        {"%bx", "bx", 3},
        !            73:        {"%cx", "cx", 3},
        !            74:        {"%dx", "dx", 3},
        !            75:        {"%si", "si", 3},
        !            76:        {"%di", "di", 3},
        !            77:        {"%bp", "bp", 3},
        !            78:        {"%sp", "sp", 3},
        !            79:        {"%al", "al", 3},
        !            80:        {"%bl", "bl", 3},
        !            81:        {"%cl", "cl", 3},
        !            82:        {"%dl", "dl", 3},
        !            83:        {"%ah", "ah", 3},
        !            84:        {"%bh", "bh", 3},
        !            85:        {"%ch", "ch", 3},
        !            86:        {"%dh", "dh", 3},
        !            87:        {"%st(0)", "st(0)", 6},
        !            88:        {"%st(1)", "st(1)", 6},
        !            89:        {"%st(2)", "st(2)", 6},
        !            90:        {"%st(3)", "st(3)", 6},
        !            91:        {"%st(4)", "st(4)", 6},
        !            92:        {"%st(5)", "st(5)", 6},
        !            93:        {"%st(6)", "st(6)", 6},
        !            94:        {"%st(7)", "st(7)", 6},
        !            95: };
        !            96: 
        !            97: int    numregs = sizeof (reglist) / sizeof (reglist[0]);
        !            98: 
        !            99: //==============================================
        !           100: 
        !           101: 
        !           102: void emitanoperand (int tnum, char *type, int notdata)
        !           103: {
        !           104:        int             i, index, something_outside_parens, regfound;
        !           105:        int             parencount;
        !           106:        char    *pt;
        !           107:        char    temp[MAX_TOKEN_LENGTH+1];
        !           108: 
        !           109:        pt = tokens[tnum];
        !           110: 
        !           111:        if (pt[0] == '%')
        !           112:        {
        !           113:        // register
        !           114:                for (i=0 ; i<numregs ; i++)
        !           115:                {
        !           116:                        if (!strcmpi (pt, reglist[i].text))
        !           117:                        {
        !           118:                                printf ("%s", reglist[i].emit);
        !           119:                                return;
        !           120:                        }
        !           121:                }
        !           122: 
        !           123:                fprintf (stderr, "Error: bad register %s\n", pt);
        !           124:                errorexit ();
        !           125:        }
        !           126:        else if (pt[0] == '$')
        !           127:        {
        !           128:        // constant
        !           129:                if (pt[1] == '(')
        !           130:                {
        !           131:                        if ((pt[2] > '9') || (pt[2] < '0'))
        !           132:                        {
        !           133:                                i = 2;
        !           134:                                printf ("offset ");
        !           135: 
        !           136:                                parencount = 1;
        !           137: 
        !           138:                                while ((pt[i] != ')') || (parencount > 1))
        !           139:                                {
        !           140:                                        if (!pt[i])
        !           141:                                        {
        !           142:                                                fprintf (stderr, "mismatched parens");
        !           143:                                                errorexit ();
        !           144:                                        }
        !           145: 
        !           146:                                        if (pt[i] == ')')
        !           147:                                                parencount--;
        !           148:                                        else if (pt[i] == '(')
        !           149:                                                parencount++;
        !           150: 
        !           151:                                        printf ("%c", pt[i]);
        !           152:                                        i++;
        !           153:                                }
        !           154:                        }
        !           155:                        else
        !           156:                        {
        !           157:                                pt++;
        !           158: 
        !           159:                                parencount = 1;
        !           160: 
        !           161:                                for (i=1 ; (pt[i] != ')') || (parencount > 1) ; i++)
        !           162:                                {
        !           163:                                        if (!pt[i])
        !           164:                                        {
        !           165:                                                fprintf (stderr, "mismatched parens");
        !           166:                                                errorexit ();
        !           167:                                        }
        !           168: 
        !           169:                                        if (pt[i] == ')')
        !           170:                                                parencount--;
        !           171:                                        else if (pt[i] == '(')
        !           172:                                                parencount++;
        !           173:                                }
        !           174: 
        !           175:                                pt[i] = 0;
        !           176: 
        !           177:                                if ((pt[1] == '0') && ((pt[2] == 'x') || (pt[2] == 'X')))
        !           178:                                {
        !           179:                                        printf ("0%sh", &pt[3]);
        !           180:                                }
        !           181:                                else
        !           182:                                {
        !           183:                                        printf ("%s", &pt[1]);
        !           184:                                }
        !           185:                        }
        !           186:                }
        !           187:                else if ((pt[1] == '0') && ((pt[2] == 'x') || (pt[2] == 'X')))
        !           188:                {
        !           189:                        printf ("0%sh", &pt[3]);
        !           190:                }
        !           191:                else if ((pt[1] >= '0') && (pt[1] <= '9'))
        !           192:                {
        !           193:                        printf ("%s", &pt[1]);
        !           194:                }
        !           195:                else
        !           196:                {
        !           197:                        printf ("offset %s", &pt[1]);
        !           198:                }
        !           199:        }
        !           200:        else if (!notdata && ((pt[0] >= '0') && (pt[0] <= '9')))
        !           201:        {
        !           202:                pt--;
        !           203: 
        !           204:                if ((pt[1] == '0') && ((pt[2] == 'x') || (pt[2] == 'X')))
        !           205:                {
        !           206:                        printf ("0%sh", &pt[3]);
        !           207:                }
        !           208:                else
        !           209:                {
        !           210:                        printf ("%s", &pt[1]);
        !           211:                }
        !           212:        }
        !           213:        else
        !           214:        {
        !           215:        // must be a memory location
        !           216:                strcpy (temp, type);
        !           217:                index = strlen (temp);
        !           218: 
        !           219:                if (notdata)
        !           220:                        temp[index++] = '[';
        !           221: 
        !           222:                something_outside_parens = 0;
        !           223: 
        !           224:                while (*pt)
        !           225:                {
        !           226:                        if (index > (MAX_TOKEN_LENGTH - 10))
        !           227:                        {
        !           228:                                fprintf (stderr, "Error: operand too long %s\n",
        !           229:                                                 tokens[tnum]);
        !           230:                                errorexit ();
        !           231:                        }
        !           232: 
        !           233:                        if (*pt != ')')
        !           234:                        {
        !           235:                                if (*pt == '(')
        !           236:                                {
        !           237:                                        if (something_outside_parens)
        !           238:                                                temp[index++] = '+';
        !           239:                                }
        !           240:                                else if (*pt == '%')
        !           241:                                {
        !           242:                                        regfound = 0;
        !           243: 
        !           244:                                        for (i=0 ; i<numregs ; i++)
        !           245:                                        {
        !           246:                                                if (!strnicmp (pt, reglist[i].text,
        !           247:                                                        reglist[i].len))
        !           248:                                                {
        !           249:                                                        strcpy (&temp[index], reglist[i].emit);
        !           250:                                                        index += strlen (reglist[i].emit);
        !           251:                                                        pt += strlen (reglist[i].text) - 1;
        !           252:                                                        regfound = 1;
        !           253:                                                        break;
        !           254:                                                }
        !           255:                                        }
        !           256: 
        !           257:                                        if (!regfound)
        !           258:                                        {
        !           259:                                                fprintf (stderr, "Error: bad register %s\n", pt);
        !           260:                                                errorexit ();
        !           261:                                        }
        !           262:                                }
        !           263:                                else if (*pt == ',')
        !           264:                                {
        !           265:                                        pt++;
        !           266: 
        !           267:                                        if ((*pt >= '1') && (*pt <= '8'))
        !           268:                                        {
        !           269:                                                temp[index++] = '*';
        !           270:                                                temp[index++] = *pt;
        !           271:                                        }
        !           272:                                        else if (*pt != ')')
        !           273:                                        {
        !           274:                                                if (temp[index-1] != '+')
        !           275:                                                        temp[index++] = '+';
        !           276:                                        }
        !           277:                                }
        !           278:                                else
        !           279:                                {
        !           280:                                        something_outside_parens = 1;
        !           281: 
        !           282:                                        // handle hexadecimal constants in addresses
        !           283:                                        if ((*pt == '0') &&
        !           284:                                                ((*(pt+1) == 'x') || (*(pt+1) == 'X')))
        !           285:                                        {
        !           286:                                                pt += 2;
        !           287: 
        !           288:                                                do
        !           289:                                                {
        !           290:                                                        temp[index++] = *pt++;
        !           291:                                                } while (((*pt >= '0') && (*pt <= '9'))     ||
        !           292:                                                                 ((*pt >= 'a') && (*pt <= 'f')) ||
        !           293:                                                                 ((*pt >= 'A') && (*pt <= 'F')));
        !           294: 
        !           295:                                                pt--;
        !           296:                                                temp[index++] = 'h';
        !           297:                                        }
        !           298:                                        else
        !           299:                                        {
        !           300:                                                temp[index++] = *pt;
        !           301:                                        }
        !           302:                                }
        !           303:                        }
        !           304: 
        !           305:                        pt++;
        !           306:                }
        !           307: 
        !           308:                if (notdata)
        !           309:                        temp[index++] = ']';
        !           310: 
        !           311:                temp[index] = 0;
        !           312:                printf ("%s", temp);
        !           313:        }
        !           314: }
        !           315: 
        !           316: 
        !           317: void datasegstart (void)
        !           318: {
        !           319:        if (currentseg == DATASEG)
        !           320:                return;
        !           321: 
        !           322:        if (currentseg == TEXTSEG)
        !           323:                printf ("_TEXT ENDS\n");
        !           324: 
        !           325:        printf ("_DATA SEGMENT");
        !           326: 
        !           327:        currentseg = DATASEG;
        !           328: }
        !           329: 
        !           330: 
        !           331: void textsegstart (void)
        !           332: {
        !           333:        if (currentseg == TEXTSEG)
        !           334:                return;
        !           335: 
        !           336:        if (currentseg == DATASEG)
        !           337:                printf ("_DATA ENDS\n");
        !           338: 
        !           339:        printf ("_TEXT SEGMENT");
        !           340: 
        !           341:        currentseg = TEXTSEG;
        !           342: }
        !           343: 
        !           344: 
        !           345: void emitdata (void)
        !           346: {
        !           347:        int             i;
        !           348: 
        !           349:        for (i=1 ; i<(tokennum-1) ; i++)
        !           350:                printf (" %s,", tokens[i]);
        !           351: 
        !           352:        printf (" %s", tokens[tokennum-1]);
        !           353: }
        !           354: 
        !           355: 
        !           356: void emitonedata (void)
        !           357: {
        !           358: 
        !           359:        printf (" %s", tokens[1]);
        !           360: }
        !           361: 
        !           362: 
        !           363: void emitonecalldata (void)
        !           364: {
        !           365:        int     i, isaddr, len;
        !           366: 
        !           367:        if (tokens[1][0] == '*')
        !           368:        {
        !           369:                printf (" dword ptr[%s]", &tokens[1][1]);
        !           370:        }
        !           371:        else
        !           372:        {
        !           373:                isaddr = 0;
        !           374:                len = strlen(tokens[1]);
        !           375: 
        !           376:                for (i=0 ; i<len ; i++)
        !           377:                {
        !           378:                        if (tokens[1][i] == '(')
        !           379:                        {
        !           380:                                isaddr = 1;
        !           381:                                break;
        !           382:                        }
        !           383:                }
        !           384: 
        !           385:                if (!isaddr)
        !           386:                {
        !           387:                        printf (" near ptr %s", tokens[1]);
        !           388:                }
        !           389:                else
        !           390:                {
        !           391:                        emitanoperand (1, " dword ptr", 1);
        !           392:                }
        !           393:        }
        !           394: }
        !           395: 
        !           396: 
        !           397: void emitonejumpdata (void)
        !           398: {
        !           399:        int     i, isaddr, len;
        !           400: 
        !           401:        if (tokens[1][0] == '*')
        !           402:        {
        !           403:                printf (" dword ptr[%s]", &tokens[1][1]);
        !           404:        }
        !           405:        else
        !           406:        {
        !           407:                isaddr = 0;
        !           408:                len = strlen(tokens[1]);
        !           409: 
        !           410:                for (i=0 ; i<len ; i++)
        !           411:                {
        !           412:                        if (tokens[1][i] == '(')
        !           413:                        {
        !           414:                                isaddr = 1;
        !           415:                                break;
        !           416:                        }
        !           417:                }
        !           418: 
        !           419:                if (!isaddr)
        !           420:                {
        !           421:                        printf (" %s", tokens[1]);
        !           422:                }
        !           423:                else
        !           424:                {
        !           425:                        emitanoperand (1, " dword ptr", 1);
        !           426:                }
        !           427:        }
        !           428: }
        !           429: 
        !           430: 
        !           431: void emitexterndef (void)
        !           432: {
        !           433: 
        !           434:        printf (" %s:dword", tokens[1]);
        !           435: }
        !           436: 
        !           437: 
        !           438: void nooperands (void)
        !           439: {
        !           440: 
        !           441: }
        !           442: 
        !           443: 
        !           444: void emitoneoperandl (void)
        !           445: {
        !           446: 
        !           447:        printf (" ");
        !           448:        emitanoperand (1, "ds:dword ptr", 1);
        !           449: }
        !           450: 
        !           451: 
        !           452: void emitoneoperandb (void)
        !           453: {
        !           454: 
        !           455:        printf (" ");
        !           456:        emitanoperand (1, "ds:byte ptr", 1);
        !           457: }
        !           458: 
        !           459: 
        !           460: void emitoneoperandw (void)
        !           461: {
        !           462: 
        !           463:        printf (" ");
        !           464:        emitanoperand (1, "ds:word ptr", 1);
        !           465: }
        !           466: 
        !           467: 
        !           468: void emittwooperandsl (void)
        !           469: {
        !           470: 
        !           471:        printf (" ");
        !           472:        emitanoperand (2, "ds:dword ptr", 1);
        !           473:        printf (",");
        !           474:        emitanoperand (1, "ds:dword ptr", 1);
        !           475: }
        !           476: 
        !           477: 
        !           478: void emittwooperandsb (void)
        !           479: {
        !           480: 
        !           481:        printf (" ");
        !           482:        emitanoperand (2, "ds:byte ptr", 1);
        !           483:        printf (",");
        !           484:        emitanoperand (1, "ds:byte ptr", 1);
        !           485: }
        !           486: 
        !           487: 
        !           488: void emittwooperandsw (void)
        !           489: {
        !           490: 
        !           491:        printf (" ");
        !           492:        emitanoperand (2, "ds:word ptr", 1);
        !           493:        printf (",");
        !           494:        emitanoperand (1, "ds:word ptr", 1);
        !           495: }
        !           496: 
        !           497: 
        !           498: void emit_0_or_1_operandsl (void)
        !           499: {
        !           500: 
        !           501:        if (tokennum == 2)
        !           502:        {
        !           503:                printf (" ");
        !           504:                emitanoperand (1, "ds:dword ptr", 1);
        !           505:        }
        !           506: }
        !           507: 
        !           508: 
        !           509: void emit_1_or_2_operandsl (void)
        !           510: {
        !           511:        int             j;
        !           512: 
        !           513:        if (tokennum == 2)
        !           514:        {
        !           515:                printf (" ");
        !           516:                emitanoperand (1, "ds:dword ptr", 1);
        !           517:        }
        !           518:        else if (tokennum == 3)
        !           519:        {
        !           520:                printf (" ");
        !           521:                emitanoperand (2, "ds:dword ptr", 1);
        !           522:                printf (",");
        !           523:                emitanoperand (1, "ds:dword ptr", 1);
        !           524:        }
        !           525:        else
        !           526:        {
        !           527: 
        !           528:                fprintf (stderr, "Error: too many operands\n");
        !           529: 
        !           530:                for (j=0 ; j<tokennum ; j++)
        !           531:                        fprintf (stderr, "%s\n", tokens[j]);
        !           532: 
        !           533:                fprintf (stderr, "\n");
        !           534:                errorexit ();
        !           535:        }
        !           536: }
        !           537: 
        !           538: 
        !           539: void emit_1_or_2_operandsl_vartext (char *str0, char *str1)
        !           540: {
        !           541:        int             j;
        !           542: 
        !           543:        if (tokennum == 2)
        !           544:        {
        !           545:                printf (" %s ", str0);
        !           546:                emitanoperand (1, "ds:dword ptr", 1);
        !           547:        }
        !           548:        else if (tokennum == 3)
        !           549:        {
        !           550:                if (!strcmpi (tokens[2], "%st(0)"))
        !           551:                        printf (" %s ", str0);
        !           552:                else
        !           553:                        printf (" %s ", str1);
        !           554: 
        !           555:                emitanoperand (2, "ds:dword ptr", 1);
        !           556:                printf (",");
        !           557:                emitanoperand (1, "ds:dword ptr", 1);
        !           558:        }
        !           559:        else
        !           560:        {
        !           561: 
        !           562:                fprintf (stderr, "Error: too many operands\n");
        !           563: 
        !           564:                for (j=0 ; j<tokennum ; j++)
        !           565:                        fprintf (stderr, "%s\n", tokens[j]);
        !           566: 
        !           567:                fprintf (stderr, "\n");
        !           568:                errorexit ();
        !           569:        }
        !           570: }
        !           571: 
        !           572: 
        !           573: void special_fdivl (void)
        !           574: {
        !           575: 
        !           576:        emit_1_or_2_operandsl_vartext ("fdiv", "fdivr");
        !           577: }
        !           578: 
        !           579: 
        !           580: void special_fdivpl (void)
        !           581: {
        !           582: 
        !           583:        emit_1_or_2_operandsl_vartext ("fdivp", "fdivrp");
        !           584: }
        !           585: 
        !           586: 
        !           587: void special_fdivrl (void)
        !           588: {
        !           589: 
        !           590:        emit_1_or_2_operandsl_vartext ("fdivr", "fdiv");
        !           591: }
        !           592: 
        !           593: 
        !           594: void special_fdivrpl (void)
        !           595: {
        !           596: 
        !           597:        emit_1_or_2_operandsl_vartext ("fdivrp", "fdivp");
        !           598: }
        !           599: 
        !           600: 
        !           601: void special_fsubl (void)
        !           602: {
        !           603: 
        !           604:        emit_1_or_2_operandsl_vartext ("fsub", "fsubr");
        !           605: }
        !           606: 
        !           607: 
        !           608: void special_fsubpl (void)
        !           609: {
        !           610: 
        !           611:        emit_1_or_2_operandsl_vartext ("fsubp", "fsubrp");
        !           612: }
        !           613: 
        !           614: 
        !           615: void special_fsubrl (void)
        !           616: {
        !           617: 
        !           618:        emit_1_or_2_operandsl_vartext ("fsubr", "fsub");
        !           619: }
        !           620: 
        !           621: 
        !           622: void special_fsubrpl (void)
        !           623: {
        !           624: 
        !           625:        emit_1_or_2_operandsl_vartext ("fsubrp", "fsubp");
        !           626: }
        !           627: 
        !           628: 
        !           629: void emit_multiple_data (void)
        !           630: {
        !           631:        int             i;
        !           632: 
        !           633:        printf (" ");
        !           634: 
        !           635:        for (i=1 ; i<(tokennum-1) ; i++)
        !           636:        {
        !           637:                emitanoperand (i, "", 0);
        !           638:                printf (", ");
        !           639:        }
        !           640: 
        !           641:        emitanoperand (i, "", 0);
        !           642: }
        !           643: 
        !           644: 
        !           645: //==============================================
        !           646: 
        !           647: parsefield     parsedata[] = {
        !           648:        {".align", " align", 2, emitonedata},
        !           649:        {".byte",  " db", -2, emit_multiple_data},
        !           650:        {".data",  "", 1, datasegstart},
        !           651:        {".extern"," externdef", 2, emitexterndef},
        !           652:        {".globl", " public", -2, emit_multiple_data},
        !           653:        {".long",  " dd", -2, emit_multiple_data},
        !           654:        {".single"," dd", -2, emit_multiple_data},
        !           655:        {".text",  "", 1, textsegstart},
        !           656:        {"adcl",   " adc", 3, emittwooperandsl},
        !           657:        {"addb",   " add", 3, emittwooperandsb},
        !           658:        {"addl",   " add", 3, emittwooperandsl},
        !           659:        {"andb",   " and", 3, emittwooperandsb},
        !           660:        {"andl",   " and", 3, emittwooperandsl},
        !           661:        {"call",   " call", 2, emitonecalldata},
        !           662:        {"cmpb",   " cmp", 3, emittwooperandsb},
        !           663:        {"cmpl",   " cmp", 3, emittwooperandsl},
        !           664:        {"cmpw",   " cmp", 3, emittwooperandsw},
        !           665:        {"decl",   " dec", 2, emitoneoperandl},
        !           666:        {"decw",   " dec", 2, emitoneoperandw},
        !           667:        {"divl",   " div", 2, emitoneoperandl},
        !           668:        {"fadd",   " fadd", -2, emit_1_or_2_operandsl},
        !           669:        {"faddp",  " faddp", -2, emit_1_or_2_operandsl},
        !           670:        {"faddps", " faddp", -2, emit_1_or_2_operandsl},
        !           671:        {"fadds",  " fadd", -2, emit_1_or_2_operandsl},
        !           672:        {"fcom",   " fcom", 2, emitoneoperandl},
        !           673:        {"fcoms",  " fcom", 2, emitoneoperandl},
        !           674:        {"fcomp",  " fcomp", 2, emitoneoperandl},
        !           675:        {"fcomps", " fcomp", 2, emitoneoperandl},
        !           676:        {"fdiv",   "", -2, special_fdivl}, 
        !           677:        {"fdivp",  "", -2, special_fdivpl}, 
        !           678:        {"fdivr",  "", -2, special_fdivrl},
        !           679:        {"fdivrp", "", -2, special_fdivrpl},
        !           680:        {"fdivrs", "", -2, special_fdivrl},
        !           681:        {"fildl",  " fild", 2, emitoneoperandl},
        !           682:        {"fistl",  " fist", 2, emitoneoperandl},
        !           683:        {"fistpl", " fistp", 2, emitoneoperandl},
        !           684:        {"fld",    " fld", 2, emitoneoperandl},
        !           685:        {"fldcw",  " fldcw", 2, emitoneoperandw},
        !           686:        {"fldenv", " fldenv", 2, emitoneoperandl},
        !           687:        {"flds",   " fld", 2, emitoneoperandl},
        !           688:        {"fmul",   " fmul", -2, emit_1_or_2_operandsl},
        !           689:        {"fmulp",  " fmulp", -2, emit_1_or_2_operandsl},
        !           690:        {"fmulps", " fmulp", -2, emit_1_or_2_operandsl},
        !           691:        {"fmuls",  " fmul", -2, emit_1_or_2_operandsl},
        !           692:        {"fnstcw", " fnstcw", 2, emitoneoperandw},
        !           693:        {"fnstenv"," fnstenv", 2, emitoneoperandl},
        !           694:        {"fnstsw", " fnstsw", 2, emitoneoperandw},
        !           695:        {"fstp",   " fstp", 2, emitoneoperandl},
        !           696:        {"fstps",  " fstp", 2, emitoneoperandl},
        !           697:        {"fsts",   " fst", 2, emitoneoperandl},
        !           698:        {"fsubr",  "", -2, special_fsubrl},
        !           699:        {"fsubrp", "", -2, special_fsubrpl},
        !           700:        {"fsubrs", "", -2, special_fsubrl},
        !           701:        {"fsub",   "", -2, special_fsubl},
        !           702:        {"fsubp",  "", -2, special_fsubpl},
        !           703:        {"fsubps", "", -2, special_fsubpl},
        !           704:        {"fsubs",  "", -2, special_fsubl},
        !           705:        {"fxch",   " fxch", 2, emitoneoperandl},
        !           706:        {"imull",  " imul", -2, emit_1_or_2_operandsl},
        !           707:        {"incl",   " inc", 2, emitoneoperandl},
        !           708:        {"ja",     " ja", 2, emitonedata},
        !           709:        {"jae",    " jae", 2, emitonedata},
        !           710:        {"jb",     " jb", 2, emitonedata},
        !           711:        {"jbe",    " jbe", 2, emitonedata},
        !           712:        {"jc",     " jc", 2, emitonedata},
        !           713:        {"je",     " je", 2, emitonedata},
        !           714:        {"jg",     " jg", 2, emitonedata},
        !           715:        {"jge",    " jge", 2, emitonedata},
        !           716:        {"jl",     " jl", 2, emitonedata},
        !           717:        {"jle",    " jle", 2, emitonedata},
        !           718:        {"jmp",    " jmp", 2, emitonejumpdata},
        !           719:        {"jna",    " jna", 2, emitonedata},
        !           720:        {"jnae",   " jnae", 2, emitonedata},
        !           721:        {"jnb",    " jnb", 2, emitonedata},
        !           722:        {"jnbe",   " jnbe", 2, emitonedata},
        !           723:        {"jnc",    " jnc", 2, emitonedata},
        !           724:        {"jne",    " jne", 2, emitonedata},
        !           725:        {"jng",    " jng", 2, emitonedata},
        !           726:        {"jnge",   " jnge", 2, emitonedata},
        !           727:        {"jnl",    " jnl", 2, emitonedata},
        !           728:        {"jnle",   " jnle", 2, emitonedata},
        !           729:        {"jns",    " jns", 2, emitonedata},
        !           730:        {"jnz",    " jnz", 2, emitonedata},
        !           731:        {"js",     " js", 2, emitonedata},
        !           732:        {"jz",     " jz", 2, emitonedata},
        !           733:        {"leal",   " lea", 3, emittwooperandsl},
        !           734:        {"movb",   " mov", 3, emittwooperandsb},
        !           735:        {"movl",   " mov", 3, emittwooperandsl},
        !           736:        {"movw",   " mov", 3, emittwooperandsw},
        !           737:        {"negl",   " neg", 2, emitoneoperandl},
        !           738:        {"orb",    " or", 3, emittwooperandsb},
        !           739:        {"orl",    " or", 3, emittwooperandsl},
        !           740:        {"popl",   " pop", 2, emitoneoperandl},
        !           741:        {"pushl",  " push", 2, emitoneoperandl},
        !           742:        {"ret",    " ret", -1, emit_0_or_1_operandsl},
        !           743:        {"rorl",   " ror", 3, emittwooperandsl},
        !           744:        {"sarl",   " sar", 3, emittwooperandsl},
        !           745:        {"sbbl",   " sbb", 3, emittwooperandsl},
        !           746:        {"shll",   " shl", 3, emittwooperandsl},
        !           747:        {"shrl",   " shr", 3, emittwooperandsl},        
        !           748:        {"subl",   " sub", 3, emittwooperandsl},
        !           749:        {"testb",  " test", 3, emittwooperandsb},
        !           750:        {"testl",  " test", 3, emittwooperandsl},
        !           751:        {"xorb",   " xor", 3, emittwooperandsb},
        !           752:        {"xorl",   " xor", 3, emittwooperandsl},
        !           753: };
        !           754: 
        !           755: int    numparse = sizeof (parsedata) / sizeof (parsedata[0]);
        !           756: 
        !           757: //==============================================
        !           758: 
        !           759: void errorexit (void)
        !           760: {
        !           761:        fprintf (stderr, "In line: %d, out line: %d\n", inline, outline);
        !           762:        exit (1);
        !           763: }
        !           764: 
        !           765: 
        !           766: tokenstat whitespace (char c)
        !           767: {
        !           768:        if (c == '\n')
        !           769:                return LINE_DONE;
        !           770: 
        !           771:        if ((c <= ' ') ||
        !           772:                (c > 127) ||
        !           773:                (c == ','))
        !           774:        {
        !           775:                return WHITESPACE;
        !           776:        }
        !           777: 
        !           778:        return NOT_WHITESPACE;
        !           779: }
        !           780: 
        !           781: 
        !           782: int gettoken (void)
        !           783: {
        !           784:        char            c;
        !           785:        int                     count, parencount;
        !           786:        tokenstat       stat;
        !           787: 
        !           788:        do
        !           789:        {
        !           790:                if ((c = getchar ()) == EOF)
        !           791:                        return FILE_DONE;
        !           792: 
        !           793:                if ((stat = whitespace (c)) == LINE_DONE)
        !           794:                        return LINE_DONE;
        !           795:        } while (stat == WHITESPACE);
        !           796: 
        !           797:        token[0] = c;
        !           798:        count = 1;
        !           799: 
        !           800:        if (c == '~')
        !           801:        {
        !           802:                count--;
        !           803:                token[count++] = 'n';
        !           804:                token[count++] = 'o';
        !           805:                token[count++] = 't';
        !           806:                token[count++] = ' ';
        !           807:        }
        !           808: 
        !           809:        if (c == '(')
        !           810:        {
        !           811:                do
        !           812:                {
        !           813:                        if ((c = getchar ()) == EOF)
        !           814:                        {
        !           815:                                fprintf (stderr, "EOF in middle of parentheses\n");
        !           816:                                errorexit ();
        !           817:                        }
        !           818: 
        !           819:                        token[count++] = c;
        !           820: 
        !           821:                } while (c != ')');
        !           822:        }
        !           823:        
        !           824:        for ( ;; )
        !           825:        {
        !           826:                if ((c = getchar ()) == EOF)
        !           827:                {
        !           828:                        token[count] = 0;
        !           829:                        return TOKEN_AVAILABLE;
        !           830:                }
        !           831: 
        !           832:                if (whitespace (c) == LINE_DONE)
        !           833:                {
        !           834:                        if (ungetc (c, stdin) == EOF)
        !           835:                        {
        !           836:                                fprintf (stderr, "Couldn't unget character\n");
        !           837:                                errorexit ();
        !           838:                        }
        !           839: 
        !           840:                        token[count] = 0;
        !           841:                        return TOKEN_AVAILABLE;
        !           842:                }
        !           843: 
        !           844:                if (whitespace (c) == WHITESPACE)
        !           845:                {
        !           846:                        token[count] = 0;
        !           847:                        return TOKEN_AVAILABLE;
        !           848:                }
        !           849: 
        !           850:                if (count >= MAX_TOKEN_LENGTH)
        !           851:                {
        !           852:                        fprintf (stderr, "Error: token too long\n");
        !           853:                        errorexit ();
        !           854:                }
        !           855: 
        !           856:                token[count++] = c;
        !           857: 
        !           858:                if (c == '~')
        !           859:                {
        !           860:                        count--;
        !           861:                        token[count++] = 'n';
        !           862:                        token[count++] = 'o';
        !           863:                        token[count++] = 't';
        !           864:                        token[count++] = ' ';
        !           865:                }
        !           866:                else if (c == '(')
        !           867:                {
        !           868:                        parencount = 1;
        !           869: 
        !           870:                        do
        !           871:                        {
        !           872:                                if ((c = getchar ()) == EOF)
        !           873:                                {
        !           874:                                        fprintf (stderr, "EOF in middle of parentheses\n");
        !           875:                                        errorexit ();
        !           876:                                }
        !           877: 
        !           878:                                if (c == '(')
        !           879:                                        parencount++;
        !           880:                                else if (c == ')')
        !           881:                                        parencount--;
        !           882: 
        !           883:                                if (c == '~')
        !           884:                                {
        !           885:                                        token[count++] = 'n';
        !           886:                                        token[count++] = 'o';
        !           887:                                        token[count++] = 't';
        !           888:                                        token[count++] = ' ';
        !           889:                                }
        !           890:                                else
        !           891:                                {
        !           892:                                        token[count++] = c;
        !           893:                                }
        !           894: 
        !           895:                        } while ((c != ')') || (parencount > 0));
        !           896:                }
        !           897:        }
        !           898: }
        !           899: 
        !           900: 
        !           901: tokenstat parseline (void)
        !           902: {
        !           903:        tokenstat       stat;
        !           904:        int                     i, j, firsttoken, labelfound;
        !           905:        int                     mnemfound;
        !           906: 
        !           907:        firsttoken = 1;
        !           908:        tokennum = 0;
        !           909:        labelfound = 0;
        !           910: 
        !           911:        for ( ;; )
        !           912:        {
        !           913:                token = tokens[tokennum];
        !           914:                stat = gettoken ();
        !           915: 
        !           916:                switch (stat)
        !           917:                {
        !           918:                case FILE_DONE:
        !           919:                        return FILE_DONE;
        !           920: 
        !           921:                case LINE_DONE:
        !           922:                        if (!firsttoken && tokennum)
        !           923:                        {
        !           924:                                mnemfound = 0;
        !           925: 
        !           926:                                for (i=0 ; i<numparse; i++)
        !           927:                                {
        !           928:                                        if (!strcmpi (tokens[0], parsedata[i].text))
        !           929:                                        {
        !           930:                                                if (((parsedata[i].numtokens > 0) &&
        !           931:                                                         (parsedata[i].numtokens != tokennum)) ||
        !           932:                                                        ((parsedata[i].numtokens < 0) &&
        !           933:                                                         (tokennum < -parsedata[i].numtokens)))
        !           934:                                                {
        !           935:                                                        fprintf (stderr, "mismatched number of tokens\n");
        !           936: 
        !           937:                                                        for (j=0 ; j<tokennum ; j++)
        !           938:                                                                fprintf (stderr, "%s\n", tokens[j]);
        !           939: 
        !           940:                                                        fprintf (stderr, "\n");
        !           941:                                                        errorexit ();
        !           942:                                                }
        !           943: 
        !           944:                                                printf ("%s", parsedata[i].emit);
        !           945:                                                (*parsedata[i].parsefunc) ();
        !           946: 
        !           947:                                                mnemfound = 1;
        !           948:                                                break;
        !           949:                                        }
        !           950:                                }
        !           951: 
        !           952:                                if (!mnemfound)
        !           953:                                {
        !           954:                                        fprintf (stderr, "Error: unknown mnemonic\n");
        !           955: 
        !           956:                                        for (j=0 ; j<tokennum ; j++)
        !           957:                                                fprintf (stderr, "%s\n", tokens[j]);
        !           958: 
        !           959:                                        fprintf (stderr, "\n");
        !           960:                                        errorexit ();
        !           961:                                }
        !           962:                        }
        !           963: 
        !           964:                        if (!firsttoken)
        !           965:                        {
        !           966:                                if ((currentseg == DATASEG) && labelfound && !tokennum)
        !           967:                                        printf (":\n");
        !           968:                                else
        !           969:                                        printf ("\n");
        !           970: 
        !           971:                                outline++;
        !           972:                        }
        !           973:                        return PARSED_OKAY;
        !           974: 
        !           975:                case TOKEN_AVAILABLE:
        !           976:                        if (firsttoken)
        !           977:                        {
        !           978:                                if (token[strlen(token) - 1] == ':')
        !           979:                                {
        !           980:                                        labelfound = 1;
        !           981: 
        !           982:                                        if (currentseg == DATASEG)
        !           983:                                        {
        !           984:                                                token[strlen(token) - 1] = 0;
        !           985:                                                printf ("%s", token);
        !           986:                                        }
        !           987:                                        else if (currentseg == TEXTSEG)
        !           988:                                        {
        !           989:                                                printf ("%s", token);
        !           990:                                        }
        !           991:                                        else
        !           992:                                        {
        !           993:                                                fprintf (stderr, "Error: not in segment block\n");
        !           994:                                                errorexit ();
        !           995:                                        }
        !           996: 
        !           997:                                        firsttoken = 0;
        !           998:                                        break;
        !           999:                                }
        !          1000:                        }
        !          1001: 
        !          1002:                        firsttoken = 0;
        !          1003: 
        !          1004:                        if (tokennum >= MAX_TOKENS)
        !          1005:                        {
        !          1006:                                fprintf (stderr, "Error: too many tokens\n");
        !          1007:                                exit (0);
        !          1008:                        }
        !          1009: 
        !          1010:                        tokennum++;
        !          1011: 
        !          1012:                        break;
        !          1013: 
        !          1014:                default:
        !          1015:                        fprintf (stderr, "Error: unknown tokenstat %d\n", stat);
        !          1016:                        exit (0);
        !          1017:                }
        !          1018:        }
        !          1019: }
        !          1020: 
        !          1021: 
        !          1022: void main (int argc, char **argv)
        !          1023: {
        !          1024:        tokenstat       stat;
        !          1025: 
        !          1026:        printf (" .386P\n"
        !          1027:             " .model FLAT\n");
        !          1028:        inline = 1;
        !          1029:        outline = 3;
        !          1030: 
        !          1031:        for ( ;; )
        !          1032:        {
        !          1033:                stat = parseline ();
        !          1034:                inline++;
        !          1035: 
        !          1036:                switch (stat)
        !          1037:                {
        !          1038:                case FILE_DONE:
        !          1039:                        if (currentseg == TEXTSEG)
        !          1040:                                printf ("_TEXT ENDS\n");
        !          1041:                        else if (currentseg == DATASEG)
        !          1042:                                printf ("_DATA ENDS\n");
        !          1043: 
        !          1044:                        printf (" END\n");
        !          1045:                        exit (0);
        !          1046:                
        !          1047:                case PARSED_OKAY:
        !          1048:                        break;
        !          1049: 
        !          1050:                default:
        !          1051:                        fprintf (stderr, "Error: unknown tokenstat %d\n", stat);
        !          1052:                        exit (0);
        !          1053:                }
        !          1054:        }
        !          1055: }
        !          1056: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.