home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / fish / disks / d1074.lha / Programs / C_dt / source / cdt.y < prev    next >
Encoding:
Lex Description  |  1995-04-01  |  14.1 KB  |  707 lines
  1. %{
  2. /*
  3. ** $PROJECT: c.datatype
  4. **
  5. ** $VER: cdt.y 39.4 (24.03.95)
  6. **
  7. ** by
  8. **
  9. ** Stefan Ruppert , Windthorststraße 5 , 65439 Flörsheim , GERMANY
  10. **
  11. ** (C) Copyright 1995
  12. ** All Rights Reserved !
  13. **
  14. ** $HISTORY:
  15. **
  16. ** 24.03.95 : 039.004 : missing else keyword added
  17. ** 23.03.95 : 039.003 : now full tabs handling
  18. ** 12.03.95 : 039.002 : added C++ keywords
  19. ** 07.03.95 : 039.001 : initial
  20. */
  21.  
  22. #include "classbase.h"
  23.  
  24. void add_line(struct ClassBase *cb,struct CParse *cparse,ULONG index,UWORD flags)
  25. {
  26.     struct Style *style = &cparse->Data->cd_CStyle[index];
  27.     struct Line *line;
  28.  
  29.     /* ignore segments , which are marked as text and no tabs are found ! */
  30.     if(!(style->Style == ~0 && index != C_STANDARD && cparse->XOffsetAdd == 0))
  31.     {
  32.         if((line = AllocPooled(cparse->Data->cd_Pool,sizeof(struct Line))))
  33.         {
  34.             STRPTR ptr = cparse->SegPtr;
  35.             ULONG x = cparse->XOffsetAdd;
  36.  
  37.             while(*ptr == ' ' || *ptr == '\t')
  38.             {
  39.                 if(*ptr == ' ')
  40.                     x += cparse->TabWidth;
  41.                 ptr++;
  42.             }
  43.  
  44.             line->ln_Text    = ptr;
  45.             line->ln_TextLen = cparse->ActPtr - ptr;
  46.  
  47.             if((flags & LNF_LF) && line->ln_TextLen > 0)
  48.                 line->ln_TextLen--;
  49.  
  50.             line->ln_XOffset = cparse->XOffset + x;
  51.             line->ln_YOffset = cparse->YOffset;
  52.             line->ln_Width   = TextLength(cparse->RPort,line->ln_Text,line->ln_TextLen) + x;
  53.             line->ln_Height  = cparse->RPort->TxHeight;
  54.             line->ln_Flags   = flags;
  55.             line->ln_FgPen   = style->FgPen;
  56.             line->ln_BgPen   = style->BgPen;
  57.             line->ln_Style   = style->Style;
  58.  
  59.             if(flags & LNF_LF)
  60.             {
  61.                 if(cparse->XOffset + line->ln_Width > cparse->MaxWidth)
  62.                     cparse->MaxWidth = cparse->XOffset + line->ln_Width;
  63.  
  64.                 cparse->YOffset += line->ln_Height;
  65.                 cparse->XOffset  = 0;
  66.             } else
  67.             {
  68.                 cparse->XOffset += line->ln_Width;
  69.  
  70.                 D({
  71.                     STRPTR ptr = &line->ln_Text[line->ln_TextLen];
  72.                     UBYTE help = *ptr;
  73.  
  74.                     *ptr = '\0';
  75.                     bug("text : %s\n",line->ln_Text);
  76.                     *ptr = help;
  77.                   });
  78.             }
  79.  
  80.             cparse->XOffsetAdd = 0;
  81.             cparse->SegPtr  = cparse->ActPtr;
  82.  
  83.             AddTail(cparse->LineList,(struct Node *) line);
  84.         }
  85.     }
  86. }
  87.  
  88. void add_cexpr(struct ClassBase *cb,struct CParse *cparse,ULONG index,BOOL lf)
  89. {
  90.     if(cparse->TxtPtr > cparse->SegPtr)
  91.     {
  92.         STRPTR actptr = cparse->ActPtr;
  93.         ULONG index = (cparse->Mode < C_MAX) ? cparse->Mode : C_STANDARD;
  94.         ULONG x = cparse->XOffsetAdd;
  95.  
  96.         cparse->XOffsetAdd = 0;
  97.         cparse->ActPtr = cparse->TxtPtr;
  98.  
  99.         add_line(cb,cparse,index,0);
  100.  
  101.         cparse->XOffsetAdd = x;
  102.         cparse->SegPtr = cparse->ActPtr;
  103.         cparse->ActPtr = actptr;
  104.     }
  105.  
  106.  
  107.     add_line(cb,cparse,index,lf);
  108.  
  109.     cparse->TxtPtr = cparse->ActPtr;
  110. }
  111.  
  112. /* don't use stdio.h, because I use the AmigaOS calls */
  113. #define _STDIO_H
  114.  
  115. %}
  116.  
  117. %pure_parser
  118.  
  119. /* cpp keywords */
  120. %token T_INCLUDE T_DEFINE T_UNDEF T_PRAGMA T_LINE T_ERROR
  121. %token T_IF T_IFDEF T_IFNDEF T_ELIF T_ENDIF
  122.  
  123. /* storage class */
  124. %token T_AUTO T_EXTERN T_REGISTER T_STATIC
  125.  
  126. /* type specifiers */
  127. %token T_CHAR T_SHORT T_INT T_LONG
  128. %token T_SIGNED T_UNSIGNED T_FLOAT T_DOUBLE T_VOID
  129.  
  130. /* other c keywords */
  131. %token T_SWITCH T_CASE T_BREAK T_DEFAULT
  132. %token T_IF T_ELSE T_FOR T_DO T_WHILE T_CONTINUE
  133. %token T_CONST T_VOLATILE
  134. %token T_GOTO
  135. %token T_RETURN
  136.  
  137. %token T_STRUCT T_UNION T_ENUM T_TYPEDEF
  138. %token T_SIZEOF
  139.  
  140. /* C++ keywords */
  141. %token T_CLASS T_PUBLIC T_PRIVATE T_PROTECTED
  142. %token T_VIRTUAL T_FRIEND
  143. %token T_NEW T_DELETE T_OPERATOR
  144. %token T_TRY T_CATCH T_THROW
  145. %token T_INLINE
  146.  
  147. /* identifier */
  148. %token T_ID
  149. /* one char */
  150. %token T_CHR
  151. /* any number constant */
  152. %token T_NUMBER
  153.  
  154. %%
  155.  
  156. input:  statement
  157.         | input statement
  158. ;
  159.  
  160. statement:
  161.           '#'                { cparse->Mode = C_CPP; }
  162.           cpp                { cparse->Mode = C_STANDARD; }
  163.         | '\n'               { add_cexpr(cb,cparse,C_STANDARD,LNF_LF); }
  164.         | simple_type_name   { add_cexpr(cb,cparse,C_TYPES,0);   }
  165.         | storage_class      { add_cexpr(cb,cparse,C_STORAGE,0); }
  166.         | keywords
  167.         | textlist
  168. ;
  169.  
  170. cpp:
  171.           cppline     '\n'         { add_cexpr(cb,cparse,C_STANDARD,LNF_LF); }
  172. ;
  173.  
  174. cppline:
  175.           cppkeyword               { add_cexpr(cb,cparse,C_CPP,0); cparse->Mode = C_CPPTEXTLIST; }
  176.           cpptextlist
  177.         | define
  178. ;
  179.  
  180. cppkeyword:
  181.           T_INCLUDE
  182.         | T_UNDEF
  183.         | T_PRAGMA
  184.         | T_LINE
  185.         | T_ERROR
  186.         | T_IF
  187.         | T_IFDEF
  188.         | T_IFNDEF
  189.         | T_ELIF
  190.         | T_ENDIF
  191.         | T_ELSE
  192. ;
  193.  
  194. cpptextlist:
  195.         | textlist
  196. ;
  197.  
  198. define:
  199.           T_DEFINE                 { add_cexpr(cb,cparse,C_CPP,0); cparse->Mode = C_CPPTEXTLIST; }
  200.           T_ID                     { cparse->TxtPtr = cparse->ActPtr;  }
  201.           definelist
  202. ;
  203.  
  204. definelist:
  205.         | definetextlist
  206. ;
  207.  
  208. definetextlist:
  209.           definetext                { if(cparse->XOffsetAdd) add_cexpr(cb,cparse,C_STANDARD,0);
  210.                                                 cparse->TxtPtr = cparse->ActPtr;   }
  211.         | definetextlist definetext { if(cparse->XOffsetAdd) add_cexpr(cb,cparse,C_STANDARD,0);
  212.                                                 cparse->TxtPtr = cparse->ActPtr;   }
  213. ;
  214.  
  215. definetext:
  216.           T_ID
  217.         | T_CHR
  218.         | T_NUMBER                 { add_cexpr(cb,cparse,C_NUMBER,0);   }
  219.         | '"' string '"'           { add_cexpr(cb,cparse,C_STRING,0);   }
  220.         | '\'' char '\''           { add_cexpr(cb,cparse,C_STRING,0);   }
  221.         | '#'                      { cparse->TxtPtr = cparse->ActPtr;   }
  222.         | '\\' '\n'                { add_cexpr(cb,cparse,C_STANDARD,LNF_LF); }
  223.           definelist
  224. ;
  225.  
  226.  
  227.  
  228. keywords:
  229.           keywordsincomplete       { add_cexpr(cb,cparse,C_KEYWORD,0); }
  230.         | keywordscomplete
  231.  
  232. keywordsincomplete:
  233.           T_CONST
  234.         | T_VOLATILE
  235.         | T_SWITCH
  236.         | T_CASE
  237.         | T_BREAK
  238.         | T_IF
  239.         | T_ELSE
  240.         | T_FOR
  241.         | T_DO
  242.         | T_WHILE
  243.         | T_CONTINUE
  244.         | T_RETURN
  245.         | T_DEFAULT
  246.         | T_GOTO
  247.         | T_TYPEDEF
  248.         | T_SIZEOF
  249.         | T_PUBLIC
  250.         | T_PRIVATE
  251.         | T_PROTECTED
  252.         | T_VIRTUAL
  253.         | T_FRIEND
  254.         | T_NEW
  255.         | T_DELETE
  256.         | T_OPERATOR
  257.         | T_TRY
  258.         | T_CATCH
  259.         | T_THROW
  260.         | T_INLINE
  261. ;
  262.  
  263. keywordscomplete:
  264.           elaborated_type_specifier
  265. ;
  266.  
  267. elaborated_type_specifier:
  268.           class_key                { add_cexpr(cb,cparse,C_KEYWORD,0); }
  269.           elaborated_type_specifier_name
  270.         | T_ENUM                   { add_cexpr(cb,cparse,C_KEYWORD,0); }
  271.           elaborated_type_specifier_name
  272. ;
  273.  
  274. class_key:
  275.           T_STRUCT
  276.         | T_UNION
  277.         | T_CLASS
  278. ;
  279.  
  280. elaborated_type_specifier_name:
  281.         | T_ID                     { add_cexpr(cb,cparse,C_TYPENAME,0); }
  282. ;
  283.  
  284. simple_type_name:
  285.           T_CHAR
  286.         | T_SHORT
  287.         | T_INT
  288.         | T_LONG
  289.         | T_SIGNED
  290.         | T_UNSIGNED
  291.         | T_FLOAT
  292.         | T_DOUBLE
  293.         | T_VOID
  294. ;
  295.  
  296. storage_class:
  297.           T_AUTO
  298.         | T_EXTERN
  299.         | T_STATIC
  300.         | T_REGISTER
  301. ;
  302.  
  303. textlist:
  304.           text                     { if(cparse->XOffsetAdd) add_cexpr(cb,cparse,C_STANDARD,0);
  305.                                               cparse->TxtPtr = cparse->ActPtr; }
  306.         | textlist text            { if(cparse->XOffsetAdd) add_cexpr(cb,cparse,C_STANDARD,0);
  307.                                               cparse->TxtPtr = cparse->ActPtr; }
  308. ;
  309.  
  310. text:
  311.           T_ID                     {  }
  312.         | T_CHR
  313.         | T_NUMBER                 { add_cexpr(cb,cparse,C_NUMBER,0); }
  314.         | '\''
  315.           char
  316.           '\''                     { add_cexpr(cb,cparse,C_STRING,0); }
  317.         | '"'                      { cparse->ActPtr--;add_cexpr(cb,cparse,C_STANDARD,0);
  318.                                               cparse->ActPtr++;cparse->Mode = C_STRING;         }
  319.           string
  320.           '"'                      { add_cexpr(cb,cparse,C_STRING,0);
  321.                                               cparse->Mode = C_STANDARD; }
  322. ;
  323.  
  324. char:
  325.         | T_ID
  326.         | T_CHR
  327.         | T_NUMBER
  328.         | '"'
  329.         | '#'
  330.         | '\\' stringescaped
  331. ;
  332.  
  333. string:
  334.           stringtoken
  335.         | string stringtoken
  336. ;
  337.  
  338. stringtoken:
  339.         | T_ID
  340.         | T_CHR
  341.         | T_NUMBER
  342.         | '\''
  343.         | '#'
  344.         | '\\' stringescaped
  345. ;
  346.  
  347. stringescaped:
  348.           T_ID
  349.         | T_CHR
  350.         | T_NUMBER
  351.         | '"'
  352.         | '\\'
  353.         | '\''
  354. ;
  355.  
  356. %%
  357.  
  358. struct Keyword
  359. {
  360.     STRPTR k_Word;
  361.     int k_ID;
  362.     int k_Len;
  363. };
  364.  
  365. struct Keyword keywords[] =
  366. {
  367.     {"auto"     ,T_AUTO      ,4},
  368.     {"break"    ,T_BREAK     ,5},
  369.     {"case"     ,T_CASE      ,4},
  370.     {"catch"    ,T_CATCH     ,5},
  371.     {"char"     ,T_CHAR      ,4},
  372.     {"class"    ,T_CLASS     ,5},
  373.     {"const"    ,T_CONST     ,5},
  374.     {"continue" ,T_CONTINUE  ,8},
  375.     {"default"  ,T_DEFAULT   ,7},
  376.     {"delete"   ,T_DELETE    ,6},
  377.     {"do"       ,T_DO        ,2},
  378.     {"double"   ,T_DOUBLE    ,6},
  379.     {"enum"     ,T_ENUM      ,4},
  380.     {"else"     ,T_ELSE      ,4},
  381.     {"extern"   ,T_EXTERN    ,6},
  382.     {"float"    ,T_FLOAT     ,5},
  383.     {"for"      ,T_FOR       ,3},
  384.     {"friend"   ,T_FRIEND    ,6},
  385.     {"goto"     ,T_GOTO      ,4},
  386.     {"if"       ,T_IF        ,2},
  387.     {"inline"   ,T_INLINE    ,6},
  388.     {"int"      ,T_INT       ,3},
  389.     {"long"     ,T_LONG      ,4},
  390.     {"new"      ,T_NEW       ,3},
  391.     {"operator" ,T_OPERATOR  ,8},
  392.     {"private"  ,T_PRIVATE   ,7},
  393.     {"protected",T_PROTECTED ,9},
  394.     {"public"   ,T_PUBLIC    ,6},
  395.     {"register" ,T_REGISTER  ,8},
  396.     {"return"   ,T_RETURN    ,6},
  397.     {"short"    ,T_SHORT     ,5},
  398.     {"signed"   ,T_SIGNED    ,6},
  399.     {"sizeof"   ,T_SIZEOF    ,6},
  400.     {"static"   ,T_STATIC    ,6},
  401.     {"struct"   ,T_STRUCT    ,6},
  402.     {"switch"   ,T_SWITCH    ,6},
  403.     {"throw"    ,T_THROW     ,5},
  404.     {"try"      ,T_TRY       ,3},
  405.     {"typedef"  ,T_TYPEDEF   ,7},
  406.     {"union"    ,T_UNION     ,5},
  407.     {"unsigned" ,T_UNSIGNED  ,8},
  408.     {"virtual"  ,T_VIRTUAL   ,7},
  409.     {"void"     ,T_VOID      ,4},
  410.     {"volatile" ,T_VOLATILE  ,8},
  411.     {"while"    ,T_WHILE     ,5},
  412.     {NULL       ,0}
  413. };
  414.  
  415. struct Keyword cppkeywords[] =
  416. {
  417.     {"define"   ,T_DEFINE    ,6},
  418.     {"elif"     ,T_ELIF      ,4},
  419.     {"else"     ,T_ELSE      ,4},
  420.     {"endif"    ,T_ENDIF     ,5},
  421.     {"error"    ,T_ERROR     ,5},
  422.     {"if"       ,T_IF        ,2},
  423.     {"ifdef"    ,T_IFDEF     ,5},
  424.     {"ifndef"   ,T_IFNDEF    ,6},
  425.     {"include"  ,T_INCLUDE   ,7},
  426.     {"line"     ,T_LINE      ,4},
  427.     {"pragma"   ,T_PRAGMA    ,6},
  428.     {"undef"    ,T_UNDEF     ,5},
  429.     {NULL       ,0}
  430. };
  431.  
  432. int cdtparse_lex(int *lvalp,struct ClassBase *cb,struct CParse *cparse)
  433. {
  434.     STRPTR ptr = cparse->ActPtr;
  435.     STRPTR end = cparse->EndPtr;
  436.     STRPTR name;
  437.     ULONG tablen = cparse->Data->cd_TabLength;
  438.     ULONG addx,chrs;
  439.     struct Keyword *kw = NULL;
  440.     int retval = 0;
  441.     int len;
  442.  
  443.     if(ptr < end)
  444.     {
  445.         do
  446.         {
  447.             chrs = cparse->Chars;
  448.             while(ptr < end && (*ptr == ' ' || *ptr == '\t'))
  449.             {
  450.                 if(*ptr == '\t')
  451.                 {
  452.                     addx = (tablen - (cparse->Chars % tablen));
  453.  
  454.                     if(chrs)
  455.                         cparse->XOffsetAdd += addx * cparse->TabWidth;
  456.                     else
  457.                         cparse->XOffset    += addx * cparse->TabWidth;
  458.                     cparse->Chars      += addx;
  459.                 } else
  460.                     cparse->Chars++;
  461.  
  462.                 ptr++;
  463.             }
  464.  
  465.             /* handle comments */
  466.             if(*ptr == '/' && ptr < end - 1 && (ptr[1] == '*' || ptr[1] == '/') && cparse->Mode != C_STRING)
  467.             {
  468.                 ptr += 2;
  469.                 if(ptr[-1] == '*')
  470.                 {
  471.                     int nested = 1;
  472.  
  473.                     while(ptr < end && nested)
  474.                     {
  475.                         switch(*ptr)
  476.                         {
  477.                         case '*':
  478.                             if(ptr[1] == '/')
  479.                             {
  480.                                 nested--;
  481.                                 ptr++;
  482.                             }
  483.                             break;
  484.                         case '/':
  485.                             if(ptr[1] == '*')
  486.                             {
  487.                                 nested++;
  488.                                 ptr++;
  489.                             }
  490.                             break;
  491.                         case '\n':
  492.                             cparse->Chars = 0;
  493.                             cparse->ActPtr = ptr + 1;
  494.                             add_cexpr(cb,cparse,C_COMMENT,LNF_LF);
  495.                             break;
  496.                         case '\t':
  497.                             cparse->ActPtr = ptr;
  498.                             add_cexpr(cb,cparse,C_COMMENT,0);
  499.                             cparse->Chars--;
  500.                             chrs = cparse->Chars;
  501.                             while(*ptr == '\t')
  502.                             {
  503.                                 addx = (tablen - (cparse->Chars % tablen));
  504.  
  505.                                 if(chrs)
  506.                                     cparse->XOffsetAdd += addx * cparse->TabWidth;
  507.                                 else
  508.                                     cparse->XOffset    += addx * cparse->TabWidth;
  509.                                 cparse->Chars      += addx;
  510.                                 ptr++;
  511.                             }
  512.                             ptr--;
  513.                             cparse->Chars++;
  514.                             break;
  515.                         }
  516.                         cparse->Chars++;
  517.                         ptr++;
  518.                     }
  519.                     cparse->ActPtr = ptr;
  520.                     add_cexpr(cb,cparse,C_COMMENT,0);
  521.                 } else
  522.                 {
  523.                     while(ptr < end && *ptr != '\n')
  524.                     {
  525.                         if(*ptr == '\t')
  526.                         {
  527.                             cparse->ActPtr = ptr;
  528.                             add_cexpr(cb,cparse,C_COMMENT,0);
  529.                             chrs = cparse->Chars;
  530.                             while(*ptr == '\t')
  531.                             {
  532.                                 addx = (tablen - (cparse->Chars % tablen));
  533.  
  534.                                 if(chrs)
  535.                                     cparse->XOffsetAdd += addx * cparse->TabWidth;
  536.                                 else
  537.                                     cparse->XOffset    += addx * cparse->TabWidth;
  538.                                 cparse->Chars      += addx;
  539.                                 ptr++;
  540.                             }
  541.                         } else
  542.                             cparse->Chars++;
  543.                         ptr++;
  544.                     }
  545.                     ptr++;
  546.                     cparse->ActPtr = ptr;
  547.  
  548.                     add_cexpr(cb,cparse,C_COMMENT,LNF_LF);
  549.                 }
  550.             } else
  551.                 break;
  552.  
  553.         } while(*ptr == ' ' || *ptr == '\t' || *ptr == '/');
  554.  
  555.         if(ptr < end)
  556.         {
  557.             if(isalpha(*ptr) || *ptr == '_')
  558.             {
  559.                 name = ptr;
  560.  
  561.                 while(ptr < end && (isalpha(*ptr) || isdigit(*ptr) || *ptr == '_'))
  562.                     ptr++;
  563.  
  564.                 len  = (ptr - name);
  565.  
  566.                 ptr--;
  567.  
  568.                 retval = T_ID;
  569.  
  570.                 /* only search for keyword if it is normal text or a cppline !!! */
  571.                 if(cparse->Mode == C_CPP)
  572.                     kw = cppkeywords;
  573.                 else if(cparse->Mode == C_STANDARD)
  574.                     kw = keywords;
  575.  
  576.                 if(len > 1 && kw)
  577.                 {
  578.                     int cmp;
  579.  
  580.                     while(kw->k_Word)
  581.                     {
  582.                         if(!(cmp = strncmp(kw->k_Word,name,len)))
  583.                         {
  584.                             DB(("len = %ld , strlen(kw) = %ld\n",len,kw->k_Len));
  585.                             if(len == kw->k_Len)
  586.                             {
  587.                                 retval = kw->k_ID;
  588.                                 break;
  589.                             }
  590.                         } else if(cmp > 0)
  591.                             break;
  592.                         kw++;
  593.                     }
  594.                 }
  595.                 cparse->Chars += len;
  596.                 cparse->ActPtr = ptr + 1;
  597.             } else if(isdigit(*ptr))
  598.             {
  599.                 name = ptr;
  600.                 ptr++;
  601.  
  602.                 if(*ptr == 'x')
  603.                 {
  604.                     ptr++;
  605.                     while(ptr < end && isxdigit(*ptr))
  606.                         ptr++;
  607.                 } else
  608.                 {
  609.                     while(ptr < end && isdigit(*ptr))
  610.                         ptr++;
  611.                 }
  612.  
  613.                 ptr--;
  614.                 cparse->Chars += (ptr - name);
  615.                 cparse->ActPtr = ptr + 1;
  616.  
  617.                 retval = T_NUMBER;
  618.             } else
  619.             {
  620.                 retval = T_CHR;
  621.  
  622.                 cparse->Chars++;
  623.                 switch(*ptr)
  624.                 {
  625.                 case '\n':
  626.                     cparse->Chars = 0;
  627.                 case '"':
  628.                 case '#':
  629.                 case '\\':
  630.                 case '\'':
  631.                     retval = *ptr;
  632.                     break;
  633.                 }
  634.                 cparse->ActPtr = ptr + 1;
  635.             }
  636.         }
  637.     }
  638.  
  639.     DB(("token : %ld\n",retval));
  640.     cparse->Token = retval;
  641.  
  642.     return(retval);
  643. }
  644.  
  645. void *cdtparse_alloc(struct ClassBase *cb,struct CParse *cparse,int size)
  646. {
  647.     struct cdtMem *mem;
  648.  
  649.     if((mem = AllocPooled(cparse->Data->cd_Pool,size + sizeof(struct cdtMem))))
  650.     {
  651.         mem->Next = cparse->Memory;
  652.         mem->Size = size + sizeof(struct cdtMem);
  653.  
  654.         mem++;
  655.     }
  656.     return(mem);
  657. }
  658.  
  659. void cdtparse_free(struct ClassBase *cb,struct CParse *cparse)
  660. {
  661.     struct cdtMem *mem = cparse->Memory;
  662.     struct cdtMem *next;
  663.  
  664.     while(mem)
  665.     {
  666.         next = mem->Next;
  667.         mem--;
  668.         FreePooled(cparse->Data->cd_Pool,mem,mem->Size);
  669.         mem = next;
  670.     }
  671. }
  672.  
  673. int cdtparse_error(char *str)
  674. {
  675.     DB(("error : %s\n",str));
  676.     return(0);
  677. }
  678.  
  679. void cdtparse_parseerror(struct ClassBase *cb,struct CParse *cparse)
  680. {
  681.     char *buf;
  682.  
  683.     if((buf = AllocPooled(cparse->Data->cd_Pool,50)))
  684.     {
  685.         STRPTR seg = cparse->SegPtr;
  686.         STRPTR act = cparse->ActPtr;
  687.  
  688.         sprintf(buf,"Parse Error : last Token %4ld for line :",cparse->Token);
  689.         cparse->SegPtr = buf;
  690.         cparse->ActPtr = buf + strlen(buf);
  691.         add_line(cb,cparse,C_STANDARD,LNF_LF);
  692.  
  693.         while(seg > cparse->BegPtr && *seg != '\n')
  694.             seg--;
  695.  
  696.         if(*seg == '\n')
  697.             seg++;
  698.  
  699.         while(act < cparse->EndPtr && *act != '\n')
  700.             act++;
  701.         cparse->SegPtr = seg;
  702.         cparse->ActPtr = act;
  703.         add_line(cb,cparse,C_STANDARD,LNF_LF);
  704.     }
  705. }
  706.  
  707.