Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /* codekcpsm.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator Xilinx kcpsm                                                */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include <ctype.h>
  15.  
  16. #include "nls.h"
  17. #include "strutil.h"
  18. #include "bpemu.h"
  19. #include "asmdef.h"
  20. #include "asmsub.h"
  21. #include "asmpars.h"
  22. #include "asmitree.h"
  23. #include "asmallg.h"
  24. #include "codepseudo.h"
  25. #include "intpseudo.h"
  26. #include "codevars.h"
  27. #include "headids.h"
  28. #include "errmsg.h"
  29.  
  30. #include "codekcpsm.h"
  31.  
  32. #undef DEBUG_PRINTF
  33.  
  34. typedef struct
  35. {
  36.   const char *Name;
  37.   Word Code;
  38. } Condition;
  39.  
  40.  
  41. #define WorkOfs 0xe0
  42.  
  43. #define COND_CODE_TRUE 0
  44.  
  45. #define IOopCnt 2
  46.  
  47. #define ModNone  (-1)
  48. #define ModWReg   0
  49. #define MModWReg   (1 << ModWReg)
  50. #define ModAbs    1
  51. #define MModAbs    (1 << ModAbs)
  52. #define ModImm    4
  53. #define MModImm    (1 << ModImm)
  54. #define ModIRReg  6
  55. #define MModIRReg  (1 << ModIRReg)
  56. #define ModInd    7
  57. #define MModInd    (1 << ModInd)
  58.  
  59. static ShortInt AdrType;
  60. static Word AdrMode,AdrIndex;
  61.  
  62. static Condition *Conditions;
  63.  
  64. static CPUVar CPUKCPSM;
  65.  
  66. /*--------------------------------------------------------------------------*/
  67. /* Code Helpers */
  68.  
  69. /*!------------------------------------------------------------------------
  70.  * \fn     IsWRegCore(const char *pArg, Word *pResult)
  71.  * \brief  check whether argument is CPU register
  72.  * \param  pArg argument
  73.  * \param  pResult register number if it is
  74.  * \return True if it is
  75.  * ------------------------------------------------------------------------ */
  76.  
  77. static Boolean IsWRegCore(const char *pArg, Word *pResult)
  78. {
  79.   Boolean retValue;
  80.  
  81.   if ((strlen(pArg) < 2) || (as_toupper(*pArg) != 'S'))
  82.     retValue = False;
  83.   else
  84.   {
  85.     Boolean OK;
  86.  
  87.     *pResult = ConstLongInt(pArg + 1, &OK, 10);
  88.     if (!OK)
  89.       retValue = False;
  90.     else
  91.       retValue = (*pResult <= 15);
  92.   }
  93. #ifdef DEBUG_PRINTF
  94.   fprintf( stderr, "IsWRegCore: %s %d\n", Asc, retValue );
  95. #endif
  96.   return retValue;
  97. }
  98.  
  99. /*!------------------------------------------------------------------------
  100.  * \fn     DissectReg_KCPSM(char *pDest, size_t DestSize, tRegInt Value, tSymbolSize InpSize)
  101.  * \brief  dissect register symbols - KCPSM3 variant
  102.  * \param  pDest destination buffer
  103.  * \param  DestSize destination buffer size
  104.  * \param  Value numeric register value
  105.  * \param  InpSize register size
  106.  * ------------------------------------------------------------------------ */
  107.  
  108. static void DissectReg_KCPSM(char *pDest, size_t DestSize, tRegInt Value, tSymbolSize InpSize)
  109. {
  110.   switch (InpSize)
  111.   {
  112.     case eSymbolSize8Bit:
  113.       as_snprintf(pDest, DestSize, "S%x", (unsigned)Value);
  114.       pDest[1] = as_toupper(pDest[1]);
  115.       break;
  116.     default:
  117.       as_snprintf(pDest, DestSize, "%d-%u", (int)InpSize, (unsigned)Value);
  118.   }
  119. }
  120.  
  121. /*!------------------------------------------------------------------------
  122.  * \fn     IsWReg(const tStrComp *pArg, Word *pResult, Boolean MustBeReg)
  123.  * \brief  check whether argument is CPU register, including register aliases
  124.  * \param  pArg argument
  125.  * \param  pResult register number if it is
  126.  * \param  MustBeReg expecting register as arg?
  127.  * \return reg eval result
  128.  * ------------------------------------------------------------------------ */
  129.  
  130. static tRegEvalResult IsWReg(const tStrComp *pArg, Word *pResult, Boolean MustBeReg)
  131. {
  132.   tRegDescr RegDescr;
  133.   tEvalResult EvalResult;
  134.   tRegEvalResult RegEvalResult;
  135.  
  136.   if (IsWRegCore(pArg->str.p_str, pResult))
  137.     return eIsReg;
  138.  
  139.   RegEvalResult = EvalStrRegExpressionAsOperand(pArg, &RegDescr, &EvalResult, eSymbolSize8Bit, MustBeReg);
  140.   *pResult = RegDescr.Reg;
  141.   return RegEvalResult;
  142. }
  143.  
  144. static void DecodeAdr(const tStrComp *pArg, Byte Mask, int Segment)
  145. {
  146.   tEvalResult EvalResult;
  147.   char *p;
  148.   int ArgLen;
  149.  
  150.   AdrType = ModNone;
  151.  
  152.   /* immediate ? */
  153.  
  154.   if (*pArg->str.p_str == '#')
  155.   {
  156.     AdrMode = EvalStrIntExpressionOffsWithResult(pArg, 1, UInt8, &EvalResult);
  157.     if (EvalResult.OK)
  158.       AdrType = ModImm;
  159.     goto chk;
  160.   }
  161.  
  162.   /* Register ? */
  163.  
  164.   switch (IsWReg(pArg, &AdrMode, False))
  165.   {
  166.     case eIsReg:
  167.       AdrType = ModWReg;
  168.       goto chk;
  169.     case eIsNoReg:
  170.       break;
  171.     case eRegAbort:
  172.       return;
  173.   }
  174.  
  175.   /* indiziert ? */
  176.  
  177.   ArgLen = strlen(pArg->str.p_str);
  178.   if ((ArgLen >= 4) && (pArg->str.p_str[ArgLen - 1] == ')'))
  179.   {
  180.     p = pArg->str.p_str + ArgLen - 1;
  181.     while ((p >= pArg->str.p_str) && (*p != '('))
  182.       p--;
  183.     if (*p != '(') WrError(ErrNum_BrackErr);
  184.     else
  185.     {
  186.       tStrComp RegComp, DispComp;
  187.  
  188.       StrCompSplitRef(&DispComp, &RegComp, pArg, p);
  189.       StrCompShorten(&RegComp, 1);
  190.       if (IsWReg(&RegComp, &AdrMode, True) == eIsReg)
  191.       {
  192.         if (DispComp.str.p_str[0])
  193.           AdrIndex = EvalStrIntExpressionWithResult(&DispComp, UInt8, &EvalResult);
  194.         else
  195.         {
  196.           AdrIndex = 0;
  197.           EvalResult.OK = True;
  198.           EvalResult.AddrSpaceMask = 0;
  199.         }
  200.         if (EvalResult.OK)
  201.         {
  202.           AdrType = ModInd;
  203.           ChkSpace(SegData, EvalResult.AddrSpaceMask);
  204.         }
  205.         goto chk;
  206.       }
  207.     }
  208.   }
  209.  
  210.   /* einfache direkte Adresse ? */
  211.  
  212.   AdrMode = EvalStrIntExpressionWithResult(pArg, UInt8, &EvalResult);
  213.   if (EvalResult.OK)
  214.   {
  215.     AdrType = ModAbs;
  216.     if (Segment != SegNone)
  217.       ChkSpace(Segment, EvalResult.AddrSpaceMask);
  218.     goto chk;
  219.   }
  220.  
  221. chk:
  222.   if ((AdrType != ModNone) && ((Mask & (1 << AdrType)) == 0))
  223.   {
  224.     WrError(ErrNum_InvAddrMode);
  225.     AdrType = ModNone;
  226.   }
  227. }
  228.  
  229. static Boolean DecodeCond(char *Asc, Word *p_code)
  230. {
  231.   int Cond;
  232.  
  233.    for (Cond = 0; Conditions[Cond].Name; Cond++)
  234.      if (!strcmp(Conditions[Cond].Name, Asc))
  235.      {
  236.        *p_code = Conditions[Cond].Code;
  237.        return True;
  238.      }
  239.   return False;
  240. }
  241.  
  242. /*--------------------------------------------------------------------------*/
  243. /* Instruction Decoders */
  244.  
  245. static void DecodeFixed(Word Code)
  246. {
  247.   if (ChkArgCnt(0, 0))
  248.   {
  249.     CodeLen = 1;
  250.     WAsmCode[0] = Code;
  251.   }
  252. }
  253.  
  254. static void DecodeLOAD(Word Code)
  255. {
  256.   UNUSED(Code);
  257.  
  258.   if (ChkArgCnt(2, 2))
  259.   {
  260.     DecodeAdr(&ArgStr[1], MModWReg, SegNone);
  261.     switch (AdrType)
  262.     {
  263.       case ModWReg:
  264.       {
  265.         Word Save = AdrMode;
  266.         DecodeAdr(&ArgStr[2], MModWReg | MModAbs | MModImm, SegNone);
  267.         switch (AdrType)
  268.         {
  269.           case ModWReg:
  270. #ifdef DEBUG_PRINTF
  271.             fprintf( stderr, "LOAD-->ModWReg %d %d\n", AdrMode, Save );
  272. #endif
  273.             WAsmCode[0] = 0xc000 | (Save << 8) | ( AdrMode << 4 );
  274.             CodeLen = 1;
  275.             break;
  276.           case ModAbs:
  277. #ifdef DEBUG_PRINTF
  278.             fprintf( stderr, "LOAD-->ModAbs %d %d\n", AdrMode, Save );
  279. #endif
  280.             WAsmCode[0] = 0xc000 | (Save << 8) | ( AdrMode << 4 );
  281.             CodeLen = 1;
  282.             break;
  283.           case ModImm:
  284. #ifdef DEBUG_PRINTF
  285.             fprintf( stderr, "LOAD-->ModImm %d %d\n", AdrMode, Save );
  286. #endif
  287.             WAsmCode[0] = (Save << 8) | AdrMode;
  288.             CodeLen = 1;
  289.             break;
  290.         }
  291.         break;
  292.       }
  293.     }
  294.   }
  295. }
  296.  
  297. static void DecodeALU2(Word Code)
  298. {
  299.   if (ChkArgCnt(2, 2))
  300.   {
  301.     DecodeAdr(&ArgStr[1], MModWReg, SegNone);
  302.     switch (AdrType)
  303.     {
  304.       case ModWReg:
  305.       {
  306.         Word Save = AdrMode;
  307.         DecodeAdr(&ArgStr[2], MModAbs | MModWReg | MModImm, SegNone);
  308.         switch (AdrType)
  309.         {
  310.           case ModWReg:
  311.             WAsmCode[0] = 0xc000 | (Save << 8) | ( AdrMode << 4 ) | Code;
  312.             CodeLen = 1;
  313.             break;
  314.           case ModImm:
  315.           case ModAbs:
  316.             WAsmCode[0] = (Code << 12 ) | (Save << 8) | AdrMode;
  317.             CodeLen = 1;
  318.             break;
  319.         }
  320.         break;
  321.       }
  322.     }
  323.   }
  324. }
  325.  
  326. static void DecodeALU1(Word Code)
  327. {
  328.   if (ChkArgCnt(1, 1))
  329.   {
  330.     DecodeAdr(&ArgStr[1], MModWReg, SegNone);
  331.     switch (AdrType)
  332.     {
  333.       case ModWReg:
  334.         WAsmCode[0] = 0xd000 | (AdrMode << 8) | Code;
  335.         CodeLen = 1;
  336.         break;
  337.     }
  338.   }
  339. }
  340.  
  341. static void DecodeCALL(Word Code)
  342. {
  343.   UNUSED(Code);
  344.  
  345.   if (ChkArgCnt(1, 2))
  346.   {
  347.     Word cond_code;
  348.  
  349.     if (ArgCnt == 1)
  350.       cond_code = COND_CODE_TRUE;
  351.     else if (!DecodeCond(ArgStr[1].str.p_str, &cond_code))
  352.     {
  353.       WrStrErrorPos(ErrNum_UndefCond, &ArgStr[1]);
  354.       return;
  355.     }
  356.  
  357.     DecodeAdr(&ArgStr[ArgCnt], MModAbs | ModImm, SegCode);
  358.     switch (AdrType)
  359.     {
  360.       case ModAbs:
  361.       case ModImm:
  362.         WAsmCode[0] = 0x8300 | (cond_code << 10) | Lo(AdrMode);
  363.         CodeLen = 1;
  364.         break;
  365.     }
  366.   }
  367. }
  368.  
  369. static void DecodeJUMP(Word Code)
  370. {
  371.   UNUSED(Code);
  372.  
  373.   if (ChkArgCnt(1, 2))
  374.   {
  375.     Word cond_code;
  376.  
  377.     if (ArgCnt == 1)
  378.        cond_code= COND_CODE_TRUE;
  379.     else if (!DecodeCond(ArgStr[1].str.p_str, &cond_code))
  380.     {
  381.       WrStrErrorPos(ErrNum_UndefCond, &ArgStr[1]);
  382.       return;
  383.     }
  384.  
  385.     DecodeAdr(&ArgStr[ArgCnt], MModAbs | MModImm, SegCode);
  386.     switch (AdrType)
  387.     {
  388.       case ModAbs:
  389.       case ModImm:
  390.         WAsmCode[0] = 0x8100 | (cond_code << 10) | Lo(AdrMode);
  391.         CodeLen = 1;
  392.         break;
  393.     }
  394.   }
  395. }
  396.  
  397. static void DecodeRETURN(Word Code)
  398. {
  399.   UNUSED(Code);
  400.  
  401.   if (ChkArgCnt(0, 1))
  402.   {
  403.     Word cond_code;
  404.  
  405.     if (ArgCnt == 0)
  406.       cond_code = COND_CODE_TRUE;
  407.     else if (!DecodeCond(ArgStr[1].str.p_str, &cond_code))
  408.     {
  409.       WrStrErrorPos(ErrNum_UndefCond, &ArgStr[1]);
  410.       return ;
  411.     }
  412.  
  413.     WAsmCode[0] = 0x8080 | (cond_code << 10);
  414.     CodeLen = 1;
  415.   }
  416. }
  417.  
  418. static void DecodeIOop(Word Code)
  419. {
  420.   if (ChkArgCnt(2, 2))
  421.   {
  422.     DecodeAdr(&ArgStr[1], MModWReg, SegNone);
  423.     switch (AdrType)
  424.     {
  425.       case ModWReg:
  426.       {
  427.         Word Save = AdrMode;
  428.         DecodeAdr(&ArgStr[2], MModInd | MModImm | MModAbs, SegData);
  429.         switch (AdrType)
  430.         {
  431.           case ModInd:
  432.             WAsmCode[0] = 0x1000 | ((Code | Save) << 8) | ( AdrMode << 4);
  433.             CodeLen = 1;
  434.             break;
  435.           case ModImm:
  436.           case ModAbs:
  437.             WAsmCode[0] = ((Code | Save) << 8) | AdrMode;
  438.             CodeLen = 1;
  439.             break;
  440.         }
  441.         break;
  442.       }
  443.     }
  444.   }
  445. }
  446.  
  447. static void DecodeRETURNI(Word Code)
  448. {
  449.   UNUSED(Code);
  450.  
  451.   if (ChkArgCnt(1, 1))
  452.   {
  453.     NLS_UpString(ArgStr[1].str.p_str);
  454.     if (!strcmp(ArgStr[1].str.p_str, "ENABLE"))
  455.     {
  456.       WAsmCode[0] = 0x80f0;
  457.       CodeLen = 1;
  458.     }
  459.     else if (!strcmp(ArgStr[1].str.p_str, "DISABLE"))
  460.     {
  461.       WAsmCode[0] =  0x80d0;
  462.       CodeLen = 1;
  463.     }
  464.   }
  465. }
  466.  
  467. static void DecodeENABLE_DISABLE(Word Code)
  468. {
  469.   UNUSED(Code);
  470.  
  471.   if (ChkArgCnt(1, 1))
  472.   {
  473.     NLS_UpString(ArgStr[1].str.p_str);
  474.     if (!as_strcasecmp(ArgStr[1].str.p_str, "INTERRUPT"))
  475.     {
  476.       WAsmCode[0] = Code;
  477.       CodeLen = 1;
  478.     }
  479.   }
  480. }
  481.  
  482. static void DecodeCONSTANT(Word Code)
  483. {
  484.   UNUSED(Code);
  485.  
  486.   if (ChkArgCnt(2, 2))
  487.   {
  488.     TempResult t;
  489.     Boolean OK;
  490.  
  491.     as_tempres_ini(&t);
  492.     as_tempres_set_int(&t, EvalStrIntExpressionWithFlags(&ArgStr[2], Int32, &OK, &t.Flags));
  493.     if (OK && !mFirstPassUnknown(t.Flags))
  494.     {
  495.       SetListLineVal(&t);
  496.       PushLocHandle(-1);
  497.       EnterIntSymbol(&ArgStr[1], t.Contents.Int, SegNone, False);
  498.       PopLocHandle();
  499.     }
  500.     as_tempres_free(&t);
  501.   }
  502. }
  503.  
  504. /*--------------------------------------------------------------------------*/
  505. /* code table handling */
  506.  
  507. static void AddFixed(const char *NName, Word NCode)
  508. {
  509.   AddInstTable(InstTable, NName, NCode, DecodeFixed);
  510. }
  511.  
  512. static void AddALU2(const char *NName, Word NCode)
  513. {
  514.   AddInstTable(InstTable, NName, NCode, DecodeALU2);
  515. }
  516.  
  517. static void AddALU1(const char *NName, Word NCode)
  518. {
  519.   AddInstTable(InstTable, NName, NCode, DecodeALU1);
  520. }
  521.  
  522. static void AddIOop(const char *NName, Word NCode)
  523. {
  524.   AddInstTable(InstTable, NName, NCode, DecodeIOop);
  525. }
  526.  
  527. static void AddCondition(const char *NName, Word NCode)
  528. {
  529.   order_array_rsv_end(Conditions, Condition);
  530.   Conditions[InstrZ].Name = NName;
  531.   Conditions[InstrZ++].Code = NCode;
  532. }
  533.  
  534. static void InitFields(void)
  535. {
  536.   InstTable = CreateInstTable(201);
  537.  
  538.   add_null_pseudo(InstTable);
  539.  
  540.   AddInstTable(InstTable, "LOAD", 0, DecodeLOAD);
  541.   AddInstTable(InstTable, "CALL", 0, DecodeCALL);
  542.   AddInstTable(InstTable, "JUMP", 0, DecodeJUMP);
  543.   AddInstTable(InstTable, "RETURN", 0, DecodeRETURN);
  544.   AddInstTable(InstTable, "RETURNI", 0, DecodeRETURNI);
  545.   AddInstTable(InstTable, "ENABLE", 0x8030, DecodeENABLE_DISABLE);
  546.   AddInstTable(InstTable, "DISABLE", 0x8010, DecodeENABLE_DISABLE);
  547.   AddInstTable(InstTable, "REG", 0, CodeREG);
  548.   AddInstTable(InstTable, "NAMEREG", 0, CodeNAMEREG);
  549.   AddInstTable(InstTable, "CONSTANT", 0, DecodeCONSTANT);
  550.  
  551.   AddFixed("EI"     , 0x8030);  AddFixed("DI"     , 0x8010);
  552.   AddFixed("RETIE"  , 0x80f0);  AddFixed("RETID"  , 0x80d0);
  553.   AddFixed("NOP"    , 0xc000); /* fake */
  554.  
  555.   AddALU2("ADD"   , 0x04);
  556.   AddALU2("ADDCY" , 0x05);
  557.   AddALU2("SUB"   , 0x06);
  558.   AddALU2("SUBCY" , 0x07);
  559.   AddALU2("OR"    , 0x02);
  560.   AddALU2("AND"   , 0x01);
  561.   AddALU2("XOR"   , 0x03);
  562.  
  563.   AddALU1("SR0" , 0x0e);
  564.   AddALU1("SR1" , 0x0f);
  565.   AddALU1("SRX" , 0x0a);
  566.   AddALU1("SRA" , 0x08);
  567.   AddALU1("RR"  , 0x0c);
  568.   AddALU1("SL0" , 0x06);
  569.   AddALU1("SL1" , 0x07);
  570.   AddALU1("SLX" , 0x04);
  571.   AddALU1("SLA" , 0x00);
  572.   AddALU1("RL"  , 0x02);
  573.  
  574.   AddIOop("INPUT"  , 0xa0);
  575.   AddIOop("OUTPUT" , 0xe0);
  576.  
  577.   InstrZ = 0;
  578.   AddCondition("T"  , COND_CODE_TRUE);
  579.   AddCondition("C"  , 6); AddCondition("NC" , 7);
  580.   AddCondition("Z"  , 4); AddCondition("NZ" , 5);
  581.   AddCondition(NULL , 0);
  582.  
  583.   AddIntelPseudo(InstTable, eIntPseudoFlag_BigEndian);
  584. }
  585.  
  586. static void DeinitFields(void)
  587. {
  588.   DestroyInstTable(InstTable);
  589.   order_array_free(Conditions);
  590. }
  591.  
  592. /*---------------------------------------------------------------------*/
  593.  
  594. /*!------------------------------------------------------------------------
  595.  * \fn     InternSymbol_KCPSM(char *pArg, TempResult *pResult)
  596.  * \brief  handle built-in (register) symbols for KCPSM
  597.  * \param  pArg source argument
  598.  * \param  pResult result buffer
  599.  * ------------------------------------------------------------------------ */
  600.  
  601. static void InternSymbol_KCPSM(char *pArg, TempResult *pResult)
  602. {
  603.   Word RegNum;
  604.  
  605.   if (IsWRegCore(pArg, &RegNum))
  606.   {
  607.     pResult->Typ = TempReg;
  608.     pResult->DataSize = eSymbolSize8Bit;
  609.     pResult->Contents.RegDescr.Reg = RegNum;
  610.     pResult->Contents.RegDescr.Dissect = DissectReg_KCPSM;
  611.     pResult->Contents.RegDescr.compare = NULL;
  612.   }
  613. }
  614.  
  615. static void MakeCode_KCPSM(void)
  616. {
  617.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  618.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  619. }
  620.  
  621. static Boolean IsDef_KCPSM(void)
  622. {
  623.   return (Memo("REG"));
  624. }
  625.  
  626. static void SwitchFrom_KCPSM(void)
  627. {
  628.   DeinitFields();
  629. }
  630.  
  631. static void SwitchTo_KCPSM(void)
  632. {
  633.   const TFamilyDescr *FoundDescr;
  634.  
  635.   FoundDescr = FindFamilyByName("KCPSM");
  636.  
  637.   TurnWords = True;
  638.   SetIntConstMode(eIntConstModeIntel);
  639.  
  640.   PCSymbol = "$";
  641.   HeaderID = FoundDescr->Id;
  642.   NOPCode = 0xc0; /* nop = load s0,s0 */
  643.   DivideChars = ",";
  644.   HasAttrs = False;
  645.  
  646.   ValidSegs = (1 << SegCode) | (1 << SegData);
  647.   Grans[SegCode] = 2; ListGrans[SegCode] = 2; SegInits[SegCode] = 0; SegLimits[SegCode] = 0xff;
  648.   Grans[SegData] = 1; ListGrans[SegData] = 1; SegInits[SegData] = 0; SegLimits[SegData] = 0xff;
  649.  
  650.   MakeCode = MakeCode_KCPSM;
  651.   IsDef = IsDef_KCPSM;
  652.   InternSymbol = InternSymbol_KCPSM;
  653.   DissectReg = DissectReg_KCPSM;
  654.   SwitchFrom = SwitchFrom_KCPSM;
  655.   InitFields();
  656. }
  657.  
  658. void codekcpsm_init(void)
  659. {
  660.   CPUKCPSM = AddCPU("KCPSM", SwitchTo_KCPSM);
  661.  
  662.   AddCopyright("XILINX KCPSM(Picoblaze)-Generator (C) 2003 Andreas Wassatsch");
  663. }
  664.