external/bsd/flex/dist/tests/test-mem-nr/scanner.l

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * This file is part of flex.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * Neither the name of the University nor the names of its contributors
  17  * may be used to endorse or promote products derived from this software
  18  * without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  22  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE.
  24  */
  25
  26 %{
  27 /* A template scanner file to build "scanner.c".
  28  * The whole idea is to cause memory realloc by
  29  *  1. pushing a lot on the condition stack, and
  30  *  2. eating input greater than YY_BUF_SIZE
  31  */
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include "config.h"
  35
  36 /* Insanely small read buffer. This pretty much guarantees at least one realloc. */
  37 #ifdef YY_BUF_SIZE
  38 #undef YY_BUF_SIZE
  39 #endif
  40 #define YY_BUF_SIZE 8
  41
  42 %}
  43
  44 %option 8bit outfile="scanner.c" prefix="test"
  45 %option nounput nomain noyywrap
  46 %option warn stack nodefault
  47 %option noyyalloc noyyrealloc noyyfree
  48
  49 %x parens
  50
  51 %%
  52
  53 <INITIAL>{
  54 "("         { printf("yy_push_state(parens)\n"); yy_push_state(parens); }
  55 len=[0-9]+  { printf("About read token where %s\n",yytext); }
  56 0+          { }
  57 .|\n        { }
  58 }
  59
  60 <parens>{
  61 "("         { printf("yy_push_state(parens)\n"); yy_push_state(parens); }
  62 ")"         { printf("yy_pop_state()\n");yy_pop_state();}
  63 [^()\n]+     { }
  64 .|\n        { }
  65 }
  66
  67 %%
  68 /* total memory allocated */
  69 static size_t total_mem=0;
  70
  71 /* track the amount of memory for ptr. */
  72 struct memsz {
  73     void* p;
  74     size_t sz;
  75 };
  76
  77 static struct memsz * ptrs=0;  /* Array of pairs. */
  78 static int nptrs=0; /* Number of pairs in array. */
  79 static int arrsz=0; /* Capacity of array. */
  80
  81 static void dump_mem(FILE* fp){
  82     int i;
  83     fprintf(fp,"\tptrs[%d] = {", nptrs);
  84     for (i=0; i < arrsz; i++)
  85         fprintf(fp," {%#lx,%ld},", (long)ptrs[i].p, (long)ptrs[i].sz);
  86
  87     fprintf(fp,"}\n");
  88 }
  89
  90 void * yyalloc(yy_size_t n)
  91 {
  92     void * p;
  93     int i;
  94
  95     total_mem += n;
  96     p = (void*)malloc(n);
  97
  98     if( nptrs >= arrsz){
  99         /* increase array size by 1 */
 100         arrsz++;
 101         ptrs = (struct memsz*)realloc( ptrs, arrsz * sizeof(struct memsz));
 102         ptrs[nptrs].p = 0;
 103         ptrs[nptrs].sz = 0;
 104     }
 105
 106     /* find a null slot */
 107     for(i=0; i < arrsz ; i++)
 108         if (ptrs[i].p == 0) {
 109             ptrs[i].p = p;
 110             ptrs[i].sz = n;
 111         }
 112
 113     nptrs++;
 114     printf("yyflex_alloc(%8ld) total=%8ld return=%#10lx\n",(long)n,(long)total_mem,(long)p);
 115     dump_mem(stdout);
 116     return p;
 117 }
 118
 119 void * yyrealloc(void* p, yy_size_t n)
 120 {
 121     int i;
 122     for (i=0; i < arrsz; i++)
 123         if ( ptrs[i].p == p){
 124             total_mem -= ptrs[i].sz;
 125             total_mem += n;
 126             ptrs[i].p = (void*)realloc(p,n);
 127             ptrs[i].sz = n;
 128
 129             printf("yyflex_realloc(%#10lx,%8ld) total=%8ld return=%8lx\n",
 130                     (long)p,(long)n,(long)total_mem,(long)ptrs[i].p);
 131             dump_mem(stdout);
 132             return ptrs[i].p;
 133         }
 134
 135     fprintf(stderr,"ERROR: yyflex_realloc could not locate pointer %#lx.\n",(long)p);
 136     dump_mem(stdout);
 137     exit(1);
 138 }
 139
 140 void yyfree(void* p)
 141 {
 142     int i;
 143     for (i=0; i < arrsz; i++)
 144         if ( ptrs[i].p == p){
 145             total_mem -= ptrs[i].sz;
 146             free(p);
 147             ptrs[i].p = 0;
 148             ptrs[i].sz = 0;
 149             nptrs--;
 150             printf("yyflex_free(%#10lx) total=%8ld\n",(long)p,(long)total_mem);
 151             dump_mem(stdout);
 152             return;
 153         }
 154
 155     fprintf(stderr,"ERROR: yyflex_free could not locate pointer %#lx.\n",(long)p);
 156     dump_mem(stdout);
 157     exit(1);
 158 }
 159
 160 int main(void);
 161
 162 int
 163 main ()
 164 {
 165     arrsz = 1;
 166     ptrs  = (struct memsz*)calloc(1,sizeof(struct memsz));
 167     nptrs = 0;
 168
 169     yyin = stdin;
 170     yyout = stdout;
 171     yylex();
 172     yylex_destroy();
 173     free(ptrs);
 174
 175     if ( nptrs > 0 || total_mem > 0){
 176         fprintf(stderr,"Oops. Looks like a memory leak: nptrs=%d, unfreed memory=%ld\n",nptrs,(long)total_mem);
 177         exit(1);
 178     }
 179     printf("TEST RETURNING OK.\n");
 180     return 0;
 181 }