├── .gitignore
├── README.md
├── assets
    ├── graph_exemple.png
    └── usage.txt
├── bin
    ├── build.sh
    ├── main
    ├── run.sh
    └── test
├── source
    ├── bufferf.pas
    ├── clickf.pas
    ├── colorf.pas
    ├── entryf.pas
    ├── errorf.pas
    ├── files
    │   └── exemple_file
    ├── graphf.pas
    ├── graphs
    │   └── exemple_file.out
    ├── handlerf.pas
    ├── inputf.pas
    ├── main.pas
    ├── parserf.pas
    ├── pfile.pas
    ├── ptypef.pas
    ├── queuef.pas
    ├── string_viewf.pas
    ├── tokenizerf.pas
    └── treef.pas
└── todo.md


/.gitignore:
--------------------------------------------------------------------------------
1 | source/main
2 | source/test
3 | source/test.pas


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # TEXT AUTO COMPLETE PROJECT
  2 | This projet implements the text auto complete feature found in most of today's applications
  3 | 
  4 | ## 
  5 | 
  6 | ## PROJECT STRUCTURE
  7 | 
  8 | ```
  9 | .
 10 | ├── assets
 11 |     └── usage.txt
 12 | 
 13 | ├── bin
 14 |     ├── build.sh
 15 |     ├── main
 16 |     ├── run.sh
 17 |     └── test
 18 | 
 19 | ├── source
 20 |     ├── clickf.pas
 21 |     ├── colorf.pas
 22 |     ├── entryf.pas
 23 |     ├── errorf.pas
 24 |     ├── graphf.pas
 25 |     ├── handlerf.pas
 26 |     ├── inputf.pas
 27 |     ├── main.pas
 28 |     ├── parserf.pas
 29 |     ├── pfile.pas
 30 |     ├── ptypef.pas
 31 |     ├── queuef.pas
 32 |     ├── stackf.pas
 33 |     ├── string_viewf.pas
 34 |     ├── test.pas
 35 |     ├── tokenizerf.pas
 36 |     └── treef.pas
 37 | 
 38 |     ├── files
 39 |         └── exemple_file
 40 |     ├── graphs
 41 |         └── exemple_file.out
 42 | 
 43 | ├── todo.md
 44 | ├── README.md
 45 | ```
 46 | 
 47 | ## EXPLANATION
 48 | This project is implemented using the prefix-tree data structure 
 49 | 
 50 | ### FILES:
 51 | 
 52 | + treef.pas: contains the implementation of the prefix-tree data structure (more about the prefix-tree data structure [click here](https://en.wikipedia.org/wiki/Trie))
 53 | 
 54 | + inputf.pas: handles the user input on the command line depends on the files:
 55 |     + lexerf.pas: for lexing the user input (more about lexing  [click here](https://www.geeksforgeeks.org/introduction-of-lexical-analysis/))
 56 | 
 57 |     + tokenizerf.pas: for tokenizing the user input (more about tokenizing [click here](https://www.geeksforgeeks.org/nlp-how-tokenizing-text-sentence-words-works/))
 58 | 
 59 |     + parserf.pas: for parsing the user input and generating output (more about parsing [click here](https://www.geeksforgeeks.org/introduction-of-parsing-ambiguity-and-parsers-set-1/))
 60 |     
 61 |     + clickf.pas: for collecting the data from the user on the command line
 62 | 
 63 |     + errorf.pas: for the error handling
 64 | 
 65 | + bufferf.pas: implements the buffer data structure (more about the buffer data structure [click here](https://www.geeksforgeeks.org/gap-buffer-data-structure/))
 66 | 
 67 | + queuef.pas: implements the queue data structure (more about the queue data structure [click here](https://geeksforgeeks.org/queue-data-structure/))
 68 | 
 69 | + string_viewf.pas: implements the string view data structure (more about the string view data structure [click here](https://www.geeksforgeeks.org/class-stdstring_view-in-cpp-17/))
 70 | 
 71 | + main.pas: the main file, it generates the project output!
 72 | 
 73 | 
 74 | ## Getting Started
 75 | 
 76 | Follow these instructions to compile and run the programs:
 77 | 
 78 | ### Prerequisites
 79 | 
 80 | - **FREE PASCAL COMPILER**: Make sure you have **fpc** installed to compile the [**PASCAL**](https://www.freepascal.org/) programs.
 81 | 
 82 | ### Compilation
 83 | 
 84 | To compile the programs, use the following commands in your terminal:
 85 | 
 86 | ```bash
 87 | $ cd bin
 88 | $ ./build.sh
 89 | ```
 90 | 
 91 | 
 92 | ## Usage
 93 | 
 94 | #### EXECTUING
 95 | After compiling, run the programs as follows:
 96 | ```bash
 97 | $ ./run.sh
 98 | ```
 99 | 
100 | #
101 | 
102 | 
103 | #### COMMANDS
104 | 
105 | ```
106 | COMMANDS:
107 |         :add <filename>*                  : to add one or more files to the tree!
108 |         :show  !<options>                 : show all the words available in the tree!
109 |               options: 
110 |                     -dir                  : show the current directory for the files!
111 |                     -gdir                 : show the directory where the graphs are located!
112 |         :dir <option> <dirname>           : to set the directory in which the files exists!
113 |               options: 
114 |                     -c                   : set the files directory!
115 |                     -g                   : set the graph directory!
116 |         :graph <filename>                 : outputs a file that contains source code for the tree generation!
117 |         :q                                : exits the program!
118 | 
119 | ```
120 | 
121 | #
122 | 
123 | #### GRAPH GENERATION
124 | 
125 | For graph generation you can use:  [**graphviz**](https://edotor.net/)
126 | 
127 | just copy the source code of the graph and put it there and it will generate a graph representation of the tree made by the words entered by you!
128 | 
129 | 
130 | ##### GRAPH EXEMPLE 
131 |   ![image.png](/assets/graph_exemple.png)
132 | #
133 | 
134 | 
135 | 
136 | # Author
137 | - BOUHADDA MOHAMMED DJAOUED


--------------------------------------------------------------------------------
/assets/graph_exemple.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DjoCoding/auto/166cc208594839d694306dc6c301fce5d95e38f4/assets/graph_exemple.png


--------------------------------------------------------------------------------
/assets/usage.txt:
--------------------------------------------------------------------------------
 1 | COMMANDS:
 2 |            :add <filename>*                  : to add one or more files to the tree!
 3 |            :show  !<options>                 : show all the words available in the tree!
 4 |                   options: 
 5 |                        -dir                  : show the current directory for the files!
 6 |                        -gdir                 : show the directory where the graphs are located!
 7 |            :dir <option> <dirname>           : to set the directory in which the files exists!
 8 |                   options: 
 9 |                         -c                   : set the files directory!
10 |                         -g                   : set the graph directory!
11 |            :graph <filename>                 : outputs a file that contains source code for the tree generation! (use graphics)
12 | 
13 | 


--------------------------------------------------------------------------------
/bin/build.sh:
--------------------------------------------------------------------------------
 1 | clear
 2 | 
 3 | cd ../source
 4 | 
 5 | fpc main.pas
 6 | 
 7 | rm *.ppu *.o
 8 | 
 9 | cd ../bin
10 | 
11 | 


--------------------------------------------------------------------------------
/bin/main:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DjoCoding/auto/166cc208594839d694306dc6c301fce5d95e38f4/bin/main


--------------------------------------------------------------------------------
/bin/run.sh:
--------------------------------------------------------------------------------
1 | cd ../source
2 | 
3 | ./main
4 | 
5 | mv main ../bin
6 | 
7 | cd ../bin


--------------------------------------------------------------------------------
/bin/test:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DjoCoding/auto/166cc208594839d694306dc6c301fce5d95e38f4/bin/test


--------------------------------------------------------------------------------
/source/bufferf.pas:
--------------------------------------------------------------------------------
  1 | unit BUFFERF;
  2 | 
  3 | interface
  4 | 
  5 |     const BUFFER_SIZE = 100;
  6 | 
  7 |     type 
  8 |         buffer_type = record 
  9 |             chars: array[1..BUFFER_SIZE] of char;
 10 |             top: integer;
 11 |         end;
 12 |     
 13 |         buffer_t = ^buffer_type;
 14 | 
 15 | 
 16 |     function buffer_init(): buffer_t;
 17 |     procedure buffer_reset(buffer: buffer_t);
 18 |     procedure buffer_remove(var buffer: buffer_t);
 19 | 
 20 |     procedure push(buffer: buffer_t; c: char);
 21 |     procedure pop(buffer: buffer_t);
 22 | 
 23 |     procedure push_string(buffer: buffer_t; s: string);
 24 |     function buffer_to_string(buffer: buffer_t): string;
 25 |     procedure write_buffer(buffer: buffer_t);
 26 |     
 27 | implementation
 28 | 
 29 | procedure buffer_reset(buffer: buffer_t);
 30 | 
 31 |     begin
 32 |         buffer^.top := 0; 
 33 |     end;
 34 | 
 35 | procedure buffer_remove(var buffer: buffer_t);
 36 | 
 37 |     begin
 38 |         dispose(buffer);
 39 |         buffer := NIL; 
 40 |     end;
 41 | 
 42 | function buffer_init(): buffer_t;
 43 | 
 44 |     var buffer: buffer_t;
 45 | 
 46 |     begin
 47 |         new(buffer);
 48 |         buffer_reset(buffer);
 49 |         buffer_init := buffer;
 50 |         buffer := NIL;
 51 |     end;
 52 | 
 53 | function buffer_empty(buffer: buffer_t): boolean;
 54 | 
 55 |     begin 
 56 |         buffer_empty := (buffer^.top = 0);
 57 |     end;
 58 | 
 59 | function buffer_full(buffer: buffer_t): boolean;
 60 | 
 61 |     begin
 62 |         buffer_full := (buffer^.top = BUFFER_SIZE); 
 63 |     end;
 64 | 
 65 | procedure push(buffer: buffer_t; c: char);
 66 | 
 67 |     begin
 68 |         if (buffer_full(buffer)) then 
 69 |             begin
 70 |                 writeln('[buffer] buffer is FULL!');
 71 |                 exit(); 
 72 |             end; 
 73 |         
 74 |         inc(buffer^.top);
 75 |         buffer^.chars[buffer^.top]:= c;
 76 |     end;
 77 | 
 78 | procedure pop(buffer: buffer_t);
 79 | 
 80 |     begin
 81 |         if (buffer_empty(buffer)) then 
 82 |             exit(); 
 83 |         
 84 |         dec(buffer^.top);
 85 |     end;
 86 | 
 87 | procedure push_string(buffer: buffer_t; s: string);
 88 | 
 89 |     var i, size: integer;
 90 | 
 91 |     begin 
 92 |         size := length(s);
 93 |         for i := 1 to size do 
 94 |             push(buffer, s[i]);
 95 |     end;
 96 | 
 97 | 
 98 | function buffer_to_string(buffer: buffer_t): string;
 99 | 
100 |     var s: string;
101 |         i: integer;
102 | 
103 |     begin 
104 |         s := '';
105 |         for i := 1 to buffer^.top do 
106 |             s := s + buffer^.chars[i];
107 |         
108 |         buffer_to_string := s;
109 |     end;
110 | 
111 | 
112 | procedure write_buffer(buffer: buffer_t);
113 | 
114 |     begin 
115 |         writeln(buffer_to_string(buffer));
116 |     end;
117 | 
118 | begin 
119 | end.
120 | 
121 | 


--------------------------------------------------------------------------------
/source/clickf.pas:
--------------------------------------------------------------------------------
 1 | unit CLICKF;
 2 | 
 3 | interface
 4 | 
 5 |     uses BUFFERF, CRT;
 6 | 
 7 |     type 
 8 |         CLICK_TYPE = (NO_CLICK, CLICK);
 9 | 
10 |         CLICK_T = record    
11 |             CLICK_CHAR: char;
12 |             C_TYPE: CLICK_TYPE;
13 |         end;
14 | 
15 |     procedure get_click();
16 |     procedure handle_click(buffer: buffer_t);
17 | 
18 |     var user_click: CLICK_T;
19 | 
20 | implementation
21 | 
22 | procedure on_click();
23 | 
24 |     begin
25 |         user_click.CLICK_CHAR := readkey();
26 |         user_click.C_TYPE := CLICK;
27 |     end;
28 | 
29 | procedure on_not_click();
30 | 
31 |     begin
32 |         user_click.C_TYPE := NO_CLICK; 
33 |     end;
34 | 
35 | procedure get_click();
36 | 
37 |     begin
38 |         if KEYPRESSED then 
39 |             on_click()
40 |         else 
41 |             on_not_click();
42 |     end;
43 | 
44 | procedure handle_click(buffer: buffer_t);
45 | 
46 |     begin
47 |         get_click();
48 | 
49 |         if (user_click.C_TYPE = CLICK) then 
50 |             case user_click.CLICK_CHAR of 
51 |                 #8:    
52 |                     pop(buffer);
53 |                 #13:
54 |                     begin 
55 |                     end;
56 |                 else 
57 |                     push(buffer, user_click.CLICK_CHAR);
58 |             end;
59 |     end;
60 | 
61 | begin 
62 | end.


--------------------------------------------------------------------------------
/source/colorf.pas:
--------------------------------------------------------------------------------
 1 | unit COLORF;
 2 | 
 3 | interface
 4 | 
 5 |     uses CRT;
 6 | 
 7 |     const RED = 4;
 8 |         BLUE = 1;
 9 |         GREEN = 2;
10 | 
11 | 
12 |     procedure color_write(s: string; color: word);
13 | 
14 | implementation
15 | 
16 | procedure color_write(s: string; color: word);
17 | 
18 |     begin
19 |         TextColor(color);
20 |         writeln(s);
21 |         writeln();
22 |         TextColor(LightGray);
23 |     end;
24 | 
25 | begin 
26 | end.
27 | 
28 | 


--------------------------------------------------------------------------------
/source/entryf.pas:
--------------------------------------------------------------------------------
 1 | unit ENTRYF;
 2 | 
 3 | interface
 4 | 
 5 |     uses COLORF;
 6 | 
 7 |     procedure entry();
 8 |     
 9 | implementation
10 | 
11 | procedure entry();
12 | 
13 |     begin
14 |         color_write('     *        *      *      *********       * * *', BLUE);
15 |         color_write('    * *       *      *          *         *        *', BLUE);
16 |         color_write('   *   *      *      *          *        *          *', BLUE);
17 |         color_write('  *******     *      *          *        *          *', BLUE);
18 |         color_write(' *       *     *    *           *         *        *', BLUE);
19 |         color_write('*         *     ****            *           * * *', BLUE);
20 |         writeln();
21 |     end;
22 | 
23 | begin 
24 | end.


--------------------------------------------------------------------------------
/source/errorf.pas:
--------------------------------------------------------------------------------
 1 | unit ERRORF;
 2 | 
 3 | interface
 4 | 
 5 |     uses PFILE, COLORF;
 6 |     
 7 |     procedure usage();
 8 |     procedure error_write(s: string);
 9 | 
10 | implementation
11 | 
12 | procedure usage();
13 | 
14 |     var line: string;
15 |         stream: TEXT;
16 | 
17 |     begin 
18 |         assign(stream, '../assets/usage.txt');  
19 |         open_file(stream, 'r');
20 | 
21 |         while (not eof(stream)) do 
22 |             begin
23 |                 readln(stream, line);
24 |                 writeln(line); 
25 |             end;
26 |         
27 |         close(stream);
28 |     end;
29 | 
30 | procedure error_write(s: string);
31 | 
32 |     begin   
33 |         color_write(s, RED); 
34 |     end;
35 | 
36 | begin
37 |     
38 | end.


--------------------------------------------------------------------------------
/source/files/exemple_file:
--------------------------------------------------------------------------------
  1 | the
  2 | be
  3 | to
  4 | of
  5 | and
  6 | a
  7 | in
  8 | that
  9 | have
 10 | I
 11 | it
 12 | for
 13 | not
 14 | on
 15 | with
 16 | he
 17 | as
 18 | you
 19 | do
 20 | at
 21 | this
 22 | but
 23 | his
 24 | by
 25 | from
 26 | they
 27 | we
 28 | say
 29 | her
 30 | she
 31 | or
 32 | an
 33 | will
 34 | my
 35 | one
 36 | all
 37 | would
 38 | there
 39 | their
 40 | what
 41 | so
 42 | up
 43 | out
 44 | if
 45 | about
 46 | who
 47 | get
 48 | which
 49 | go
 50 | me
 51 | when
 52 | make
 53 | can
 54 | like
 55 | time
 56 | no
 57 | just
 58 | him
 59 | know
 60 | take
 61 | people
 62 | into
 63 | year
 64 | your
 65 | good
 66 | some
 67 | could
 68 | them
 69 | see
 70 | other
 71 | than
 72 | then
 73 | now
 74 | look
 75 | only
 76 | come
 77 | its
 78 | over
 79 | think
 80 | also
 81 | back
 82 | after
 83 | use
 84 | two
 85 | how
 86 | our
 87 | work
 88 | first
 89 | well
 90 | way
 91 | even
 92 | new
 93 | want
 94 | because
 95 | any
 96 | these
 97 | give
 98 | day
 99 | most
100 | us
101 | is
102 | are
103 | was
104 | were
105 | has
106 | been
107 | being
108 | had
109 | do
110 | did
111 | does
112 | doing
113 | might
114 | may
115 | can
116 | must
117 | could
118 | should
119 | would
120 | will
121 | shall
122 | might
123 | may
124 | can
125 | must
126 | could
127 | should
128 | would
129 | will
130 | shall
131 | am
132 | is
133 | are
134 | was
135 | were
136 | be
137 | being
138 | been
139 | do
140 | did
141 | does
142 | doing
143 | have
144 | has
145 | had
146 | having
147 | get
148 | got
149 | gotten
150 | getting
151 | go
152 | goes
153 | went
154 | gone
155 | going
156 | make
157 | makes
158 | made
159 | making
160 | take
161 | takes
162 | took
163 | taken
164 | taking
165 | come
166 | comes
167 | came
168 | come
169 | coming
170 | give
171 | gives
172 | gave
173 | given
174 | giving
175 | put
176 | puts
177 | put
178 | putting
179 | say
180 | says
181 | said
182 | saying
183 | see
184 | sees
185 | saw
186 | seen
187 | seeing
188 | look
189 | looks
190 | looked
191 | looking
192 | want
193 | wants
194 | wanted
195 | wanting
196 | use
197 | uses
198 | used
199 | using
200 | find
201 | finds
202 | found
203 | finding
204 | call
205 | calls
206 | called
207 | calling
208 | try
209 | tries
210 | tried
211 | trying
212 | need
213 | needs
214 | needed
215 | needing
216 | feel
217 | feels
218 | felt
219 | feeling
220 | become
221 | becomes
222 | became
223 | becoming
224 | leave
225 | leaves
226 | left
227 | leaving
228 | begin
229 | begins
230 | began
231 | beginning
232 | keep
233 | keeps
234 | kept
235 | keeping
236 | let
237 | lets
238 | let
239 | letting
240 | mean
241 | means
242 | meant
243 | meaning
244 | bring
245 | brings
246 | brought
247 | bringing
248 | start
249 | starts
250 | started
251 | starting
252 | talk
253 | talks
254 | talked
255 | talking
256 | show
257 | shows
258 | showed
259 | showing
260 | put
261 | puts
262 | putting
263 | putting
264 | turn
265 | turns
266 | turned
267 | turning
268 | begin
269 | begins
270 | began
271 | beginning
272 | seem
273 | seems
274 | seemed
275 | seeming
276 | does
277 | does
278 | done
279 | doing
280 | did
281 | seem
282 | seems
283 | seemed
284 | seeming
285 | did
286 | do
287 | does
288 | doing
289 | done
290 | hear
291 | hears
292 | heard
293 | hearing
294 | live
295 | lives
296 | lived
297 | living
298 | die
299 | dies
300 | died
301 | dying
302 | let
303 | lets
304 | let
305 | letting
306 | mean
307 | means
308 | meant
309 | meaning
310 | sit
311 | sits
312 | sat
313 | sitting
314 | stand
315 | stands
316 | stood
317 | standing
318 | find
319 | finds
320 | found
321 | finding
322 | fall
323 | falls
324 | fell
325 | fallen
326 | falling
327 | pay
328 | pays
329 | paid
330 | paying
331 | learn
332 | learns
333 | learned
334 | learning
335 | 


--------------------------------------------------------------------------------
/source/graphf.pas:
--------------------------------------------------------------------------------
 1 | unit GRAPHF;
 2 | 
 3 | interface
 4 | 
 5 |     uses PFILE, TREEF, QUEUEF;
 6 | 
 7 |     procedure get_graph(file_path: string);
 8 | 
 9 | implementation
10 | 
11 | procedure get_graph(var stream: TEXT);
12 | 
13 |     var child_node: node_t;
14 |         current: node_t;
15 | 
16 |     begin
17 |         queue_init();
18 |         enqueue(root);
19 | 
20 |         while (not queue_empty()) do 
21 |             begin
22 |                 current := dequeue();
23 |                 child_node := current^.child_node;
24 |                 while (child_node <> NIL) do 
25 |                     begin 
26 |                         writeln(stream, current^.value, ' -- ', child_node^.value);
27 |                         enqueue(child_node);
28 |                         child_node := child_node^.next_node;
29 |                     end;
30 |             end;
31 | 
32 |         queue_remove();
33 |     end;
34 | 
35 | procedure get_graph(file_path: string);
36 | 
37 |     var stream: TEXT;
38 | 
39 |     begin
40 |         writeln('[GRAPH MAKER] SETTING UP THE GRAPH FILE...');
41 |         writeln();
42 |         
43 |         assign(stream, file_path);
44 |         open_file(stream, 'w');
45 | 
46 |         writeln(stream, 'GRAPH {');
47 |         get_graph(stream);
48 |         writeln(stream, '}');
49 | 
50 | 
51 |         close(stream);
52 |     end;
53 | 
54 | begin 
55 | end.


--------------------------------------------------------------------------------
/source/graphs/exemple_file.out:
--------------------------------------------------------------------------------
  1 | GRAPH {
  2 | r -- e
  3 | r -- p
  4 | r -- k
  5 | r -- j
  6 | r -- l
  7 | r -- c
  8 | r -- g
  9 | r -- u
 10 | r -- m
 11 | r -- s
 12 | r -- d
 13 | r -- y
 14 | r -- w
 15 | r -- n
 16 | r -- f
 17 | r -- I
 18 | r -- h
 19 | r -- i
 20 | r -- a
 21 | r -- o
 22 | r -- b
 23 | r -- t
 24 | e -- v
 25 | p -- a
 26 | p -- u
 27 | p -- e
 28 | k -- e
 29 | k -- n
 30 | j -- u
 31 | l -- e
 32 | l -- o
 33 | l -- i
 34 | c -- o
 35 | c -- a
 36 | g -- a
 37 | g -- i
 38 | g -- o
 39 | g -- e
 40 | u -- s
 41 | u -- p
 42 | m -- u
 43 | m -- i
 44 | m -- o
 45 | m -- a
 46 | m -- e
 47 | m -- y
 48 | s -- i
 49 | s -- t
 50 | s -- e
 51 | s -- o
 52 | s -- h
 53 | s -- a
 54 | d -- y
 55 | d -- i
 56 | d -- a
 57 | d -- o
 58 | y -- e
 59 | y -- o
 60 | w -- a
 61 | w -- h
 62 | w -- o
 63 | w -- e
 64 | w -- i
 65 | n -- e
 66 | n -- o
 67 | f -- a
 68 | f -- e
 69 | f -- i
 70 | f -- r
 71 | f -- o
 72 | h -- o
 73 | h -- i
 74 | h -- e
 75 | h -- a
 76 | i -- s
 77 | i -- f
 78 | i -- t
 79 | i -- n
 80 | a -- m
 81 | a -- r
 82 | a -- f
 83 | a -- b
 84 | a -- l
 85 | a -- t
 86 | a -- s
 87 | a -- n
 88 | o -- v
 89 | o -- t
 90 | o -- u
 91 | o -- r
 92 | o -- n
 93 | o -- f
 94 | b -- r
 95 | b -- a
 96 | b -- y
 97 | b -- u
 98 | b -- e
 99 | t -- u
100 | t -- r
101 | t -- w
102 | t -- a
103 | t -- i
104 | t -- o
105 | t -- h
106 | v -- e
107 | a -- i
108 | a -- y
109 | u -- t
110 | e -- o
111 | e -- p
112 | e -- e
113 | n -- o
114 | u -- s
115 | e -- t
116 | e -- f
117 | e -- a
118 | o -- o
119 | i -- v
120 | i -- k
121 | o -- m
122 | o -- u
123 | a -- l
124 | a -- m
125 | a -- n
126 | a -- v
127 | i -- v
128 | o -- i
129 | o -- n
130 | o -- e
131 | o -- t
132 | o -- o
133 | e -- t
134 | s -- i
135 | s -- e
136 | u -- s
137 | i -- g
138 | o -- s
139 | a -- d
140 | a -- y
141 | a -- k
142 | e -- a
143 | i -- t
144 | t -- o
145 | t -- a
146 | e -- e
147 | o -- m
148 | h -- a
149 | h -- o
150 | h -- e
151 | a -- t
152 | a -- w
153 | a -- i
154 | a -- y
155 | y -- i
156 | i -- e
157 | i -- d
158 | a -- y
159 | o -- n
160 | o -- i
161 | o -- e
162 | e -- a
163 | o -- u
164 | a -- s
165 | a -- n
166 | a -- y
167 | h -- e
168 | h -- i
169 | h -- o
170 | h -- a
171 | o -- r
172 | o -- u
173 | e -- n
174 | e -- r
175 | e -- l
176 | i -- l
177 | i -- t
178 | e -- e
179 | e -- w
180 | o -- w
181 | o -- t
182 | a -- l
183 | e -- l
184 | e -- e
185 | i -- n
186 | i -- r
187 | r -- o
188 | o -- u
189 | o -- r
190 | o -- w
191 | i -- m
192 | i -- s
193 | e -- a
194 | e -- r
195 | a -- d
196 | a -- s
197 | a -- v
198 | t -- s
199 | n -- t
200 | r -- e
201 | f -- t
202 | b -- o
203 | l -- s
204 | l -- l
205 | n -- y
206 | n -- d
207 | v -- e
208 | t -- h
209 | u -- r
210 | u -- t
211 | n -- l
212 | n -- e
213 | r -- o
214 | r -- i
215 | a -- c
216 | u -- t
217 | e -- g
218 | e -- i
219 | e -- e
220 | e -- c
221 | u -- r
222 | r -- i
223 | r -- y
224 | w -- o
225 | a -- l
226 | a -- k
227 | i -- m
228 | o -- o
229 | h -- i
230 | h -- a
231 | h -- e
232 | e -- n
233 | i -- d
234 | y -- i
235 | y -- s
236 | t -- t
237 | t -- s
238 | o -- p
239 | p -- t
240 | e -- p
241 | o -- w
242 | s -- t
243 | t -- t
244 | t -- s
245 | f -- t
246 | a -- r
247 | a -- v
248 | o -- k
249 | v -- i
250 | v -- e
251 | k -- e
252 | m -- i
253 | m -- e
254 | u -- l
255 | l -- l
256 | m -- e
257 | v -- e
258 | v -- i
259 | v -- e
260 | i -- n
261 | n -- e
262 | e -- s
263 | t -- t
264 | o -- d
265 | t -- t
266 | i -- n
267 | e -- d
268 | e -- s
269 | s -- t
270 | g -- h
271 | s -- t
272 | d -- e
273 | k -- i
274 | k -- e
275 | a -- n
276 | t -- t
277 | t -- s
278 | o -- o
279 | a -- n
280 | a -- r
281 | e -- m
282 | e -- i
283 | e -- n
284 | e -- s
285 | m -- e
286 | a -- l
287 | o -- w
288 | o -- u
289 | i -- d
290 | y -- i
291 | y -- s
292 | i -- n
293 | e -- d
294 | e -- s
295 | n -- e
296 | i -- n
297 | e -- s
298 | a -- r
299 | u -- r
300 | n -- t
301 | e -- n
302 | i -- c
303 | a -- t
304 | r -- k
305 | u -- l
306 | n -- t
307 | r -- e
308 | l -- l
309 | l -- l
310 | t -- h
311 | e -- d
312 | l -- l
313 | l -- l
314 | l -- t
315 | e -- l
316 | n -- d
317 | r -- s
318 | o -- m
319 | u -- n
320 | a -- r
321 | v -- i
322 | v -- e
323 | t -- o
324 | t -- e
325 | o -- u
326 | s -- o
327 | e -- r
328 | h -- e
329 | l -- y
330 | o -- u
331 | i -- n
332 | c -- k
333 | g -- a
334 | g -- i
335 | i -- n
336 | e -- n
337 | c -- o
338 | c -- a
339 | r -- n
340 | i -- e
341 | y -- i
342 | l -- k
343 | k -- i
344 | k -- e
345 | m -- e
346 | o -- k
347 | i -- n
348 | i -- s
349 | a -- n
350 | a -- t
351 | e -- s
352 | e -- n
353 | e -- m
354 | e -- i
355 | e -- r
356 | e -- y
357 | i -- n
358 | t -- i
359 | p -- l
360 | p -- i
361 | p -- s
362 | t -- i
363 | r -- n
364 | v -- i
365 | v -- e
366 | k -- i
367 | k -- e
368 | k -- s
369 | i -- n
370 | e -- d
371 | e -- s
372 | i -- n
373 | e -- s
374 | l -- d
375 | l -- i
376 | l -- e
377 | l -- s
378 | i -- n
379 | e -- n
380 | e -- s
381 | n -- g
382 | t -- e
383 | t -- i
384 | n -- g
385 | h -- t
386 | i -- n
387 | e -- s
388 | n -- i
389 | n -- t
390 | n -- s
391 | t -- i
392 | o -- d
393 | n -- d
394 | r -- t
395 | m -- i
396 | m -- e
397 | m -- s
398 | i -- n
399 | l -- l
400 | w -- i
401 | w -- e
402 | w -- s
403 | u -- l
404 | i -- n
405 | n -- g
406 | n -- g
407 | t -- i
408 | t -- e
409 | t -- s
410 | c -- h
411 | l -- d
412 | d -- i
413 | d -- e
414 | d -- s
415 | l -- i
416 | l -- e
417 | l -- s
418 | l -- i
419 | l -- s
420 | d -- i
421 | d -- s
422 | s -- t
423 | n -- d
424 | r -- i
425 | r -- d
426 | r -- s
427 | i -- n
428 | e -- r
429 | u -- t
430 | e -- r
431 | u -- g
432 | n -- g
433 | a -- n
434 | i -- n
435 | n -- g
436 | o -- m
437 | a -- m
438 | a -- u
439 | n -- i
440 | n -- e
441 | n -- s
442 | e -- d
443 | e -- s
444 | i -- n
445 | k -- i
446 | k -- e
447 | k -- s
448 | i -- n
449 | e -- n
450 | e -- s
451 | n -- k
452 | s -- e
453 | i -- r
454 | r -- e
455 | n -- g
456 | i -- n
457 | l -- e
458 | i -- n
459 | i -- n
460 | n -- i
461 | n -- e
462 | n -- s
463 | i -- n
464 | e -- s
465 | i -- n
466 | e -- d
467 | n -- g
468 | n -- g
469 | i -- n
470 | e -- d
471 | n -- g
472 | e -- n
473 | i -- n
474 | n -- g
475 | i -- n
476 | i -- n
477 | d -- i
478 | d -- s
479 | t -- i
480 | t -- e
481 | t -- s
482 | i -- n
483 | e -- d
484 | n -- g
485 | i -- n
486 | e -- d
487 | l -- d
488 | n -- g
489 | i -- n
490 | e -- d
491 | i -- n
492 | e -- d
493 | i -- n
494 | e -- n
495 | i -- n
496 | i -- n
497 | i -- n
498 | n -- g
499 | g -- h
500 | g -- i
501 | g -- s
502 | n -- n
503 | n -- s
504 | m -- i
505 | m -- e
506 | m -- e
507 | u -- s
508 | i -- n
509 | e -- d
510 | n -- g
511 | i -- n
512 | e -- d
513 | n -- g
514 | n -- g
515 | n -- g
516 | n -- g
517 | i -- n
518 | e -- d
519 | n -- g
520 | n -- g
521 | n -- g
522 | n -- g
523 | n -- g
524 | n -- g
525 | i -- n
526 | i -- n
527 | e -- d
528 | n -- g
529 | n -- g
530 | n -- g
531 | n -- g
532 | n -- g
533 | n -- g
534 | n -- g
535 | n -- g
536 | h -- t
537 | i -- n
538 | n -- i
539 | i -- n
540 | e -- s
541 | s -- e
542 | n -- g
543 | n -- g
544 | n -- g
545 | n -- g
546 | n -- g
547 | n -- g
548 | i -- n
549 | n -- g
550 | n -- g
551 | }
552 | 


--------------------------------------------------------------------------------
/source/handlerf.pas:
--------------------------------------------------------------------------------
 1 | unit HANDLERF;
 2 | 
 3 | interface
 4 |     
 5 |     uses ENTRYF, INPUTF, CRT, TREEF, BUFFERF, CLICKF;
 6 | 
 7 |     procedure run();
 8 | 
 9 | implementation
10 | 
11 | procedure run();
12 | 
13 |     var 
14 |         HANDLING_RESULT: Boolean;
15 |         buffer: buffer_t;
16 | 
17 |     begin
18 |         // initializing 
19 |         root_init();
20 |         buffer := buffer_init();
21 | 
22 |         entry();
23 |         write('> ');
24 |         HANDLING_RESULT := FALSE;
25 | 
26 |         repeat
27 |             if (KEYPRESSED) then 
28 |                 begin 
29 |                     clrscr();
30 |                     entry();
31 |                     write('> ');
32 |                     handle_click(buffer);
33 |                     writeln(buffer_to_string(buffer));
34 |                     HANDLING_RESULT := handle_user_input(buffer);
35 |                 end;
36 |         until(HANDLING_RESULT); 
37 | 
38 |         // freeing the memory
39 |         buffer_remove(buffer);
40 |         root_remove();
41 |     end;
42 | 
43 | 
44 | begin 
45 | end.


--------------------------------------------------------------------------------
/source/inputf.pas:
--------------------------------------------------------------------------------
  1 | unit INPUTF;
  2 | 
  3 | interface
  4 | 
  5 |     uses CRT, PARSERF, ERRORF, CLICKF, GRAPHF, SYSUTILS, BUFFERF, TREEF, STRING_VIEWF, TOKENIZERF;
  6 | 
  7 |     function handle_user_input(buffer: buffer_t): boolean;
  8 | 
  9 |     var current_graph_directory: string = './';
 10 |         current_directory: string = './';
 11 | 
 12 | implementation
 13 | 
 14 | procedure handle_show_command(parser: parser_t);
 15 | 
 16 |     var current: token_t;
 17 | 
 18 |     begin
 19 |         if (not end_tokens(parser)) then 
 20 |             begin
 21 |                 current := parser_consume(parser);
 22 |                 case current^.value of 
 23 |                     '-c':   // current files directory!   
 24 |                         begin 
 25 |                             writeln('FILES AT: ', current_directory);
 26 |                             exit();
 27 |                         end;
 28 |                     '-g':  // current graphs directory!
 29 |                         begin
 30 |                             writeln('GRAPHS AT: ', current_graph_directory);
 31 |                             exit(); 
 32 |                         end;
 33 |                 else 
 34 |                     begin 
 35 |                         usage();
 36 |                         error_write('ERROR: TOKEN ' + current^.value + ' NOT EXPECTED!');
 37 |                         exit();
 38 |                     end; 
 39 |                 end;
 40 |             end;
 41 |         
 42 |         dfs_root();
 43 |         current := NIL;
 44 |     end;
 45 | 
 46 | procedure handle_add_command(parser: parser_t);
 47 | 
 48 |     var current: token_t;
 49 |         file_path: string;
 50 | 
 51 |     begin 
 52 |         writeln();
 53 | 
 54 |         if (end_tokens(parser)) then 
 55 |             begin
 56 |                 usage();
 57 |                 error_write('ERROR: EXPECTED FILE PATHS!');
 58 |                 exit(); 
 59 |             end;
 60 | 
 61 |         while (not end_tokens(parser)) do 
 62 |             begin
 63 |                 current := parser_consume(parser);
 64 |                 if (current^._type = COMMAND_TYPE) then 
 65 |                     begin
 66 |                         usage();
 67 |                         error_write('ERROR: EXPECTED FILE PATH BUT GOT COMMAND: ' + current^.value);
 68 |                         exit();
 69 |                     end; 
 70 | 
 71 |                 file_path := './' + current_directory + '/' + current^.value;
 72 | 
 73 |                 if (FileExists(file_path)) then 
 74 |                     begin 
 75 |                         append_tree_from_file(file_path);
 76 |                         writeln('FILE WITH PATH: ' + file_path + ' ADDED SUCCESSFULLY!');
 77 |                     end
 78 |                 else 
 79 |                     begin
 80 |                         usage();
 81 |                         writeln();
 82 |                         error_write('ERROR: FILE NAMED: ' + file_path + ' IS NOT FOUND!');
 83 |                         exit(); 
 84 |                     end;
 85 |             end; 
 86 |     end;
 87 | 
 88 | procedure handle_graph_command(parser: parser_t);
 89 | 
 90 |     var file_path: string;
 91 |         current: token_t;
 92 | 
 93 |     begin 
 94 |         if (end_tokens(parser)) then 
 95 |             begin
 96 |                 usage();
 97 |                 error_write('ERROR: FILE NAME EXPECTED!');
 98 |                 exit(); 
 99 |             end;
100 |         
101 |         current := parser_consume(parser);
102 | 
103 |         if (current^._type = COMMAND_TYPE) then 
104 |             begin
105 |                 usage();
106 |                 error_write('ERROR: EXPECTED FILE NAME BUT GOT COMMAND: ' + current^.value);
107 |                 exit();  
108 |             end;
109 | 
110 |         if (not end_tokens(parser)) then 
111 |             begin
112 |                 usage();
113 |                 error_write('ERROR: EXPECTED ONE FILE PATH, BUT FOUND MORE!');
114 |                 exit(); 
115 |             end;
116 |         
117 |         if (not DirectoryExists(current_graph_directory)) then 
118 |             begin 
119 |                 usage();
120 |                 error_write('ERROR: DIRECTORY ' + current_graph_directory + ' NOT FOUND!');
121 |                 exit(); 
122 |             end;
123 | 
124 |         file_path := './' + current_graph_directory + '/' + current^.value;
125 |         get_graph(file_path);
126 | 
127 |         writeln('[GRAPH MAKER] THE GRAPH FILE IS NOW AVAILABLE IN FILE: ', file_path);
128 |         writeln();
129 | 
130 |         current := NIL;
131 |     end;
132 | 
133 | 
134 | procedure handle_directory_command(parser: parser_t);
135 | 
136 |     var dir_name: string;
137 |         current: token_t;
138 | 
139 |     begin
140 |         if (end_tokens(parser)) then 
141 |             begin
142 |                 usage();
143 |                 error_write('ERROR: MORE TOKENS EXPECTED!');
144 |                 exit(); 
145 |             end;
146 | 
147 |         current := parser_consume(parser);
148 |         
149 |         // add the options for the graph directory -g and the current directory -c
150 | 
151 |         if (current^.value[1] <> '-') then 
152 |             begin
153 |                 usage();
154 |                 error_write('ERROR: OPTION EXPECTED!');
155 |                 exit(); 
156 |             end;
157 |         
158 |         if (end_tokens(parser)) then 
159 |             begin 
160 |                 usage();
161 |                 error_write('ERROR: FILE NAME EXPECTED!');
162 |                 exit(); 
163 |             end;
164 |         
165 |         dir_name := parser_consume(parser)^.value;
166 | 
167 |         case (current^.value) of 
168 |             '-g':
169 |                 current_graph_directory := dir_name;
170 |             '-c':   
171 |                 current_directory := dir_name;
172 |             else 
173 |                 begin
174 |                     usage();
175 |                     error_write('ERROR: ' + current^.value +' IS NOT AN OPTION!');
176 |                     exit(); 
177 |                 end;
178 |         end;
179 | 
180 |         current := NIL;
181 |     end;
182 | 
183 | procedure handle_no_command_input(input: string);
184 | 
185 |     begin
186 |         if (user_click.CLICK_CHAR = #13) then 
187 |             user_click.CLICK_CHAR := #4;     // that will be the signal to quit (press ENTER);
188 | 
189 |         dfs_prefix(input); 
190 |     end;
191 | 
192 | procedure handle_command_input(input: string);
193 | 
194 |     var sv: sv_t;
195 |         tokens: token_list;
196 |         current: token_t;
197 |         parser: parser_t;
198 |     
199 |     begin        
200 |         sv := sv_create(input);
201 |         tokens := get_tokens(sv);
202 | 
203 |         if (tokens^.head = NIL) then 
204 |             begin 
205 |                 sv_remove(sv);
206 |                 token_list_remove(tokens);
207 |                 exit();
208 |             end;
209 | 
210 |         parser := parser_create(tokens); // creating the parser!
211 |         current := parser_consume(parser); // consuming the first token! (the command token);
212 | 
213 |         case current^.value of 
214 |             ':add': 
215 |                 handle_add_command(parser);
216 |             ':show': 
217 |                 handle_show_command(parser);
218 |             ':graph':
219 |                 handle_graph_command(parser);
220 |             ':dir':
221 |                 handle_directory_command(parser);
222 |             ':h':
223 |                 usage();
224 |             
225 |             else 
226 |                 begin
227 |                     usage();
228 |                     error_write('ERROR: COMMAND ' + current^.value + ' NOT FOUND!'); 
229 |                 end;
230 |         end;  
231 | 
232 |         sv_remove(sv);
233 |         parser_remove(parser);
234 |         current := NIL;
235 |     end;
236 | 
237 | function handle_user_input(buffer: buffer_t): boolean;
238 | 
239 |     var input: string;
240 | 
241 |     begin
242 |         input := buffer_to_string(buffer);
243 |         handle_user_input := FALSE;
244 | 
245 |         if (input[1] = ':') then 
246 |             if (user_click.CLICK_CHAR = #13) then  // if user click = ENTER => handle the command!
247 |                 begin   
248 |                     clrscr();
249 |                     writeln('> ');
250 |                     if (input = ':q') then 
251 |                         begin 
252 |                             handle_user_input := TRUE;
253 |                             writeln('[HANDLER] QUITTING!');
254 |                             exit();
255 |                         end;
256 |                         
257 |                     handle_command_input(input);
258 |                     buffer_reset(buffer);
259 |                 end
260 |             else 
261 |                 exit()
262 |         else
263 |             handle_no_command_input(input);
264 | 
265 |     end;
266 | 
267 | begin 
268 | end.


--------------------------------------------------------------------------------
/source/main.pas:
--------------------------------------------------------------------------------
1 | uses HANDLERF;
2 | 
3 | begin
4 |     run();
5 | end.


--------------------------------------------------------------------------------
/source/parserf.pas:
--------------------------------------------------------------------------------
 1 | unit PARSERF;
 2 | 
 3 | interface
 4 | 
 5 |     uses TOKENIZERF;
 6 | 
 7 |     type 
 8 |         parser_t = ^parser_type;
 9 |         parser_type = record 
10 |             tokens: token_list;
11 |             current: token_t;
12 |         end;
13 |     
14 |     function parser_create(tokens: token_list): parser_t;
15 |     function end_tokens(parser: parser_t): boolean;
16 |     function parser_peek(parser: parser_t): token_t;
17 |     function parser_consume(parser: parser_t): token_t;
18 |     procedure parser_remove(var parser: parser_t);
19 | 
20 | 
21 | implementation
22 | 
23 | function parser_create(tokens: token_list): parser_t;
24 | 
25 |     var result: parser_t;
26 |     
27 |     begin 
28 |         new(result);
29 |         result^.tokens := tokens;
30 |         result^.current := tokens^.head;
31 |         parser_create := result;
32 |         result := NIL;
33 |     end;
34 | 
35 | procedure parser_remove(var parser: parser_t);
36 | 
37 |     begin
38 |         token_list_remove(parser^.tokens);
39 |         parser^.current := NIL;
40 |         dispose(parser);
41 |         parser := NIL;
42 |     end;
43 | 
44 | function end_tokens(parser: parser_t): boolean;
45 | 
46 |     begin
47 |         end_tokens := (parser^.current = NIL); 
48 |     end;
49 | 
50 | function parser_peek(parser: parser_t): token_t;
51 | 
52 |     begin 
53 |         parser_peek := parser^.current;
54 |     end;
55 | 
56 | function parser_consume(parser: parser_t): token_t;
57 | 
58 |     begin 
59 |         parser_consume := parser_peek(parser);
60 |         parser^.current := parser^.current^.next;
61 |     end;
62 | 
63 | begin 
64 | end.
65 | 
66 | 


--------------------------------------------------------------------------------
/source/pfile.pas:
--------------------------------------------------------------------------------
 1 | unit PFILE;
 2 | 
 3 | interface 
 4 | 
 5 |     procedure open_file(var stream: TEXT; mode: char);
 6 |         
 7 | implementation
 8 | 
 9 | procedure open_file(var stream: TEXT; mode: char);
10 | 
11 |     begin
12 |         case mode of 
13 |             'r':
14 |                 reset(stream);
15 |             'w':
16 |                 rewrite(stream);
17 |             'a': 
18 |                 append(stream);
19 |         end;
20 |     end;
21 | 
22 | begin 
23 | end.
24 | 


--------------------------------------------------------------------------------
/source/ptypef.pas:
--------------------------------------------------------------------------------
 1 | unit PTYPEF;
 2 | 
 3 | interface
 4 | 
 5 |     function iswhitespace(c: char): boolean;
 6 | 
 7 | implementation
 8 | 
 9 | function iswhitespace(c: char): boolean;
10 | 
11 |     begin
12 |         iswhitespace := (c = ' '); 
13 |     end;
14 | 
15 | begin 
16 | end.


--------------------------------------------------------------------------------
/source/queuef.pas:
--------------------------------------------------------------------------------
 1 | unit QUEUEF;
 2 | 
 3 | interface
 4 |     
 5 |     uses TREEF;
 6 | 
 7 |     const MAX_SIZE = 1000;
 8 | 
 9 |     type 
10 |         queue_type = record 
11 |             nodes: array[1..MAX_SIZE] of node_t;
12 |             back: integer;
13 |         end;
14 |     
15 |         queue_t = ^queue_type;
16 | 
17 |     procedure queue_init();
18 |     procedure queue_remove();
19 | 
20 |     procedure enqueue(node: node_t);
21 |     function dequeue(): node_t;
22 | 
23 |     function queue_empty(): boolean;
24 |     function queue_full(): boolean;
25 | 
26 |     var queue: queue_t;
27 | 
28 | implementation
29 | 
30 | function queue_full(): boolean;
31 | 
32 |     begin
33 |         queue_full := (queue^.back = MAX_SIZE); 
34 |     end;
35 | 
36 | function queue_empty(): boolean;
37 | 
38 |     begin 
39 |         queue_empty := (queue^.back = 0);
40 |     end;
41 | 
42 | procedure queue_remove();
43 | 
44 |     begin
45 |         dispose(queue);
46 |         queue := NIL; 
47 |     end;
48 | 
49 | procedure queue_init();
50 | 
51 |     begin 
52 |         queue_remove();
53 |         new(queue);
54 |         queue^.back := 0;
55 |     end;
56 | 
57 | procedure enqueue(node: node_t);
58 | 
59 |     begin
60 |         if (queue_full()) then 
61 |             begin   
62 |                 writeln('[QUEUE] queue is FULL!');
63 |                 exit();
64 |             end;
65 |         
66 |         inc(queue^.back);
67 |         queue^.nodes[queue^.back] := node;
68 |     end;
69 | 
70 | function dequeue(): node_t;
71 | 
72 |     var i: integer;
73 |     
74 |     begin 
75 |         dequeue := queue^.nodes[1];
76 | 
77 |         dec(queue^.back);
78 | 
79 |         for i := 1 to queue^.back do 
80 |             queue^.nodes[i] := queue^.nodes[i + 1];        
81 |     end;
82 | 
83 | begin 
84 | end.


--------------------------------------------------------------------------------
/source/string_viewf.pas:
--------------------------------------------------------------------------------
 1 | unit STRING_VIEWF;
 2 | 
 3 | interface 
 4 | 
 5 |     type 
 6 |         sv_t = ^sv_type;
 7 |         sv_type = record 
 8 |             content: string;
 9 |             size: integer;
10 |             current: integer;
11 |         end;
12 | 
13 |     function sv_create(content: string): sv_t;
14 |     procedure sv_remove(var sv: sv_t);
15 | 
16 |     function sv_end(sv: sv_t): boolean;
17 |     function sv_peek(sv: sv_t): char;
18 |     function sv_consume(sv: sv_t): char;
19 |     
20 | implementation
21 | 
22 | function sv_create(content: string): sv_t;
23 | 
24 |     var result: sv_t;
25 | 
26 |     begin
27 |         new(result);
28 |         result^.content := content;
29 |         result^.size := length(content);
30 |         result^.current := 1;
31 |         sv_create := result;
32 |         result := NIL;
33 |     end;
34 | 
35 | procedure sv_remove(var sv: sv_t);
36 | 
37 |     begin
38 |         dispose(sv);
39 |         sv := NIL;
40 |     end;
41 | 
42 | function sv_end(sv: sv_t): boolean;
43 | 
44 |     begin
45 |         sv_end := (sv^.current = sv^.size + 1); 
46 |     end;
47 | 
48 | function sv_peek(sv: sv_t): char;
49 | 
50 |     begin
51 |         sv_peek := sv^.content[sv^.current];
52 |     end;
53 | 
54 | function sv_consume(sv: sv_t): char;
55 | 
56 |     begin
57 |         sv_consume := sv_peek(sv);
58 |         inc(sv^.current); 
59 |     end;
60 | 
61 | begin 
62 | end.


--------------------------------------------------------------------------------
/source/tokenizerf.pas:
--------------------------------------------------------------------------------
  1 | unit TOKENIZERF;
  2 | 
  3 | interface 
  4 | 
  5 |     uses PTYPEF, STRING_VIEWF;
  6 | 
  7 |     type 
  8 |         TOKEN_TYPE = (COMMAND_TYPE, ARG_TYPE);
  9 | 
 10 |         token_t = ^token_type_t;
 11 |         token_type_t = record 
 12 |             value: string;
 13 |             _type: TOKEN_TYPE;
 14 |             next: token_t;
 15 |         end;
 16 | 
 17 |         token_list = ^token_list_type;
 18 |         token_list_type = record 
 19 |             head, tail: token_t;
 20 |         end;
 21 | 
 22 |     function get_tokens(sv: sv_t): token_list;
 23 |     procedure tokens_write(tokens: token_list);
 24 |     procedure token_list_remove(var tokens: token_list);
 25 | 
 26 | implementation
 27 | 
 28 | function token_create(value: string; _type: TOKEN_TYPE): token_t;
 29 | 
 30 |     var token: token_t;
 31 | 
 32 |     begin 
 33 |         new(token);
 34 |         token^.value := value;
 35 |         token^._type := _type;
 36 |         token^.next := NIL;
 37 |         token_create := token;
 38 |         token := NIL;
 39 |     end;
 40 | 
 41 | procedure token_list_remove(var tokens: token_list);
 42 | 
 43 |     var current: token_t;
 44 | 
 45 |     begin
 46 |         if (tokens = NIL) then exit();
 47 |         
 48 |         while (tokens^.head <> NIL) do 
 49 |             begin
 50 |                 current := tokens^.head;
 51 |                 tokens^.head := current^.next;
 52 |                 dispose(current);
 53 |             end; 
 54 |         
 55 |         current := NIL;
 56 |         tokens^.tail := NIL;
 57 |         tokens := NIL;
 58 |     end;
 59 | 
 60 | procedure token_list_init(var tokens: token_list);
 61 | 
 62 |     begin
 63 |         token_list_remove(tokens); 
 64 |         new(tokens);
 65 |         tokens^.head := NIL;
 66 |         tokens^.tail := NIL;
 67 |     end;
 68 | 
 69 | procedure add_token(tokens: token_list; token: token_t);
 70 | 
 71 |     begin
 72 |         if (tokens^.head = NIL) then 
 73 |             begin
 74 |                 tokens^.head := token;
 75 |                 tokens^.tail := token; 
 76 |             end 
 77 |         else 
 78 |             begin
 79 |                 tokens^.tail^.next := token;
 80 |                 tokens^.tail := token; 
 81 |             end;
 82 |     end;
 83 | 
 84 | function get_token_type(token_value: string): TOKEN_TYPE;
 85 | 
 86 |     begin
 87 |         case token_value[1] of 
 88 |             ':':
 89 |                 get_token_type := COMMAND_TYPE;
 90 |             else
 91 |                 get_token_type := ARG_TYPE;
 92 |         end; 
 93 |     end;
 94 | 
 95 | function get_next_token(sv: sv_t): token_t;
 96 | 
 97 |     var buffer: string;
 98 | 
 99 |     begin
100 |         buffer := '';
101 | 
102 |         while (not sv_end(sv)) do 
103 |             begin
104 |                 if (iswhitespace(sv_peek(sv))) then break; 
105 |                 buffer := buffer + sv_consume(sv);
106 |             end; 
107 |         
108 |         if (not sv_end(sv)) then 
109 |             sv_consume(sv); // consuming the whitespace!
110 |         get_next_token := token_create(buffer, get_token_type(buffer));
111 |     end;
112 | 
113 | function get_tokens(sv: sv_t): token_list;
114 | 
115 |     var tokens: token_list;
116 | 
117 |     begin
118 |         tokens := NIL;
119 |         token_list_init(tokens);
120 | 
121 | 
122 |         while (not sv_end(sv)) do 
123 |             add_token(tokens, get_next_token(sv)); 
124 | 
125 |         get_tokens := tokens; 
126 |     end;
127 | 
128 | procedure token_write(token: token_t);
129 | 
130 |     begin
131 |         writeln('TOKEN VALUE: ', token^.value);
132 |         writeln('TOKEN TYPE: ', token^._type); 
133 |     end;
134 | 
135 | procedure tokens_write(tokens: token_list);
136 | 
137 |     var current: token_t;
138 |     
139 |     begin 
140 |         current := tokens^.head;
141 | 
142 |         while (current <> NIL) do 
143 |             begin
144 |                 token_write(current);
145 |                 current := current^.next; 
146 |             end; 
147 |     end;
148 | 
149 | begin 
150 | end.
151 | 
152 | 
153 | 


--------------------------------------------------------------------------------
/source/treef.pas:
--------------------------------------------------------------------------------
  1 | unit TREEF;
  2 | 
  3 | interface   
  4 | 
  5 |     uses BUFFERF, PFILE; 
  6 | 
  7 |     type node_t = ^node_type;
  8 |         node_type = record 
  9 |             value: char;
 10 |             is_end: boolean;
 11 |             child_node, next_node: node_t;
 12 |         end;
 13 |     
 14 |     procedure root_remove();
 15 |     procedure root_init();
 16 | 
 17 |     procedure add_word_to_tree(word: string);
 18 |     procedure dfs_root();
 19 | 
 20 |     procedure dfs_prefix(prefix: string);
 21 | 
 22 |     procedure reset_tree_from_file(file_path: string);
 23 |     procedure append_tree_from_file(file_path: string);
 24 | 
 25 |     var root: node_t;
 26 | 
 27 | implementation
 28 | 
 29 | function node_create(value: char; is_end: boolean): node_t;
 30 | 
 31 |     var result: node_t;
 32 | 
 33 |     begin 
 34 |         new(result);
 35 |         result^.value := value;
 36 |         result^.is_end := is_end;
 37 |         result^.child_node := NIL;
 38 |         result^.next_node := NIL;
 39 |         node_create := result;
 40 |         result := NIL;
 41 |     end;
 42 | 
 43 | function get_child_node(node: node_t; value: char): node_t;
 44 |     
 45 |     var 
 46 |         current: node_t;
 47 | 
 48 |     begin
 49 |         current := node^.child_node;
 50 |         
 51 |         while (current <> NIL) do 
 52 |             if (current^.value = value) then break
 53 |             else 
 54 |                 current := current^.next_node;
 55 |         
 56 |         get_child_node := current;
 57 |     end;
 58 | 
 59 | // this function will returns the new node after the insertion!
 60 | function add_node_to_tree(node: node_t; value: char): node_t;
 61 | 
 62 |     var new_node: node_t;
 63 | 
 64 |     begin 
 65 |         new_node := node_create(value, FALSE); // suppose it's not the end of the word!
 66 |         new_node^.next_node := node^.child_node;
 67 |         node^.child_node := new_node;
 68 |         add_node_to_tree := new_node;
 69 |         new_node := NIL; 
 70 |     end;
 71 | 
 72 | procedure add_word_to_tree(word: string);
 73 | 
 74 |     var i, size: integer;
 75 |         child_node, current: node_t;
 76 | 
 77 |     begin
 78 |         current := root;
 79 |         size := length(word);
 80 | 
 81 |         for i := 1 to size do 
 82 |             begin
 83 |                 child_node := get_child_node(current, word[i]);
 84 |                 if (child_node = NIL) then 
 85 |                     child_node := add_node_to_tree(current, word[i]);
 86 |                 current := child_node;
 87 |             end;
 88 |         
 89 |         current^.is_end := TRUE;
 90 |         current := NIL;
 91 |         child_node := NIL;
 92 |     end;
 93 | 
 94 | function get_prefix_in_tree(prefix: string): node_t;
 95 | 
 96 |     var current: node_t;
 97 |         size, i: integer;
 98 | 
 99 |     begin
100 |         current := root;
101 |         i := 1;
102 |         size := length(prefix);
103 | 
104 |         while ((i <= size) and (current <> NIL)) do 
105 |             begin
106 |                 current := get_child_node(current, prefix[i]);
107 |                 inc(i); 
108 |             end; 
109 |         
110 |         get_prefix_in_tree := current;
111 |     end;
112 | 
113 | 
114 | procedure dfs(buffer: buffer_t; node: node_t);
115 | 
116 |     var current: node_t;
117 | 
118 |     begin
119 |         if (node = NIL) then exit();
120 | 
121 |         current := node^.child_node;
122 | 
123 |         while (current <> NIL) do 
124 |             begin
125 |                 push(buffer, current^.value);
126 |                 
127 |                 if (current^.is_end) then 
128 |                     write_buffer(buffer);
129 |                 
130 |                 dfs(buffer, current);
131 | 
132 |                 pop(buffer);
133 | 
134 |                 current := current^.next_node; 
135 |             end;
136 |     end;
137 | 
138 | procedure dfs_root();
139 | 
140 |     var buffer: buffer_t; 
141 | 
142 |     begin 
143 |         buffer := buffer_init();
144 |         dfs(buffer, root);
145 |         writeln();
146 |         buffer_remove(buffer);
147 |     end;
148 | 
149 | procedure dfs_prefix(prefix: string);
150 | 
151 |     var buffer: buffer_t;
152 |         node: node_t;
153 | 
154 |     begin
155 |         node := get_prefix_in_tree(prefix);
156 |         buffer := buffer_init();
157 | 
158 |         push_string(buffer, prefix);
159 |         dfs(buffer, node);
160 |         buffer_remove(buffer);
161 |     end;
162 | 
163 | procedure remove_sub_tree(node: node_t);
164 | 
165 |     var next, current: node_t;
166 | 
167 |     begin
168 |         if (node = NIL) then exit();
169 | 
170 |         current := node^.child_node;
171 |         while (current <> NIL) do 
172 |             begin
173 |                 next := current^.next_node;
174 |                 remove_sub_tree(current);
175 |                 dispose(current);
176 |                 current := next; 
177 |             end;
178 |     end;
179 | 
180 | procedure root_remove();
181 | 
182 |     begin 
183 |         remove_sub_tree(root);
184 |         dispose(root);
185 |         root := NIL;
186 |     end;
187 | 
188 | procedure root_init();
189 | 
190 |     begin
191 |         root_remove();
192 |         root := node_create('r', FALSE); 
193 |     end;
194 | 
195 | procedure reset_tree_from_file(file_path: string);
196 | 
197 |     begin
198 |         root_remove();
199 |         append_tree_from_file(file_path);
200 |     end;
201 | 
202 | procedure append_tree_from_file(file_path: string);
203 | 
204 |     var WORDS_FILE: TEXT;
205 |         word: string;
206 | 
207 |     begin
208 |         assign(WORDS_FILE, file_path); 
209 |         open_file(WORDS_FILE, 'r');
210 | 
211 |         while (not EOF(WORDS_FILE)) do 
212 |             begin 
213 |                 readln(WORDS_FILE, word);
214 |                 add_word_to_tree(word);
215 |             end;
216 | 
217 |         close(WORDS_FILE);
218 |     end;
219 | 
220 | 
221 | begin 
222 | end.
223 | 
224 | 


--------------------------------------------------------------------------------
/todo.md:
--------------------------------------------------------------------------------
 1 | + implement the prefix-tree data structure
 2 |     + functions needed:
 3 |         + make a node!
 4 |         + add a node!
 5 |         + bfs
 6 |         + dfs 
 7 |     
 8 |     + commands:
 9 |         + ```:add <filename>```: to add the words in the file called filename!
10 |         + ```:show ```: to show all the words available in the tree!
11 |         + ```:graph <filename>```: generates the graph file!
12 |         + ```:default <dirname>```: to search for files in the dir name!


--------------------------------------------------------------------------------