Restructure repository to include all source folders

Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

GameTools/ScriptEngine/bison.hairy

@@ -0,0 +1,668 @@
+
+
+extern int timeclock;
+
+
+
+
+
+int yyerror;		/*  Yyerror and yycost are set by guards.	*/
+
+int yycost;		/*  If yyerror is set to a nonzero value by a	*/
+
+			/*  guard, the reduction with which the guard	*/
+
+			/*  is associated is not performed, and the	*/
+
+			/*  error recovery mechanism is invoked.	*/
+
+			/*  Yycost indicates the cost of performing	*/
+
+			/*  the reduction given the attributes of the	*/
+
+			/*  symbols.					*/
+
+
+
+
+
+/*  YYMAXDEPTH indicates the size of the parser's state and value	*/
+
+/*  stacks.								*/
+
+
+
+#ifndef	YYMAXDEPTH
+
+#define	YYMAXDEPTH	500
+
+#endif
+
+
+
+/*  YYMAXRULES must be at least as large as the number of rules that	*/
+
+/*  could be placed in the rule queue.  That number could be determined	*/
+
+/*  from the grammar and the size of the stack, but, as yet, it is not.	*/
+
+
+
+#ifndef	YYMAXRULES
+
+#define	YYMAXRULES	100
+
+#endif
+
+
+
+#ifndef	YYMAXBACKUP
+
+#define YYMAXBACKUP	100
+
+#endif
+
+
+
+
+
+short	yyss[YYMAXDEPTH];	/*  the state stack			*/
+
+YYSTYPE	yyvs[YYMAXDEPTH];	/*  the semantic value stack		*/
+
+YYLTYPE yyls[YYMAXDEPTH];	/*  the location stack			*/
+
+short	yyrq[YYMAXRULES];	/*  the rule queue			*/
+
+int	yychar;			/*  the lookahead symbol		*/
+
+
+
+YYSTYPE	yylval;			/*  the semantic value of the		*/
+
+				/*  lookahead symbol			*/
+
+
+
+YYSTYPE yytval;			/*  the semantic value for the state	*/
+
+				/*  at the top of the state stack.	*/
+
+
+
+YYSTYPE yyval;			/*  the variable used to return		*/
+
+				/*  semantic values from the action	*/
+
+				/*  routines				*/
+
+
+
+YYLTYPE yylloc;		/*  location data for the lookahead	*/
+
+				/*  symbol				*/
+
+
+
+YYLTYPE yytloc;		/*  location data for the state at the	*/
+
+				/*  top of the state stack		*/
+
+
+
+
+
+int	yynunlexed;
+
+short	yyunchar[YYMAXBACKUP];
+
+YYSTYPE	yyunval[YYMAXBACKUP];
+
+YYLTYPE yyunloc[YYMAXBACKUP];
+
+
+
+short *yygssp;			/*  a pointer to the top of the state	*/
+
+				/*  stack; only set during error	*/
+
+				/*  recovery.				*/
+
+
+
+YYSTYPE *yygvsp;		/*  a pointer to the top of the value	*/
+
+				/*  stack; only set during error	*/
+
+				/*  recovery.				*/
+
+
+
+YYLTYPE *yyglsp;		/*  a pointer to the top of the		*/
+
+				/*  location stack; only set during	*/
+
+				/*  error recovery.			*/
+
+
+
+
+
+/*  Yyget is an interface between the parser and the lexical analyzer.	*/
+
+/*  It is costly to provide such an interface, but it avoids requiring	*/
+
+/*  the lexical analyzer to be able to back up the scan.		*/
+
+
+
+yyget()
+
+{
+
+  if (yynunlexed > 0)
+
+    {
+
+      yynunlexed--;
+
+      yychar = yyunchar[yynunlexed];
+
+      yylval = yyunval[yynunlexed];
+
+      yylloc = yyunloc[yynunlexed];
+
+    }
+
+  else if (yychar <= 0)
+
+    yychar = 0;
+
+  else
+
+    {
+
+      yychar = yylex();
+
+      if (yychar < 0)
+
+	yychar = 0;
+
+      else yychar = YYTRANSLATE(yychar);
+
+    }
+
+}
+
+
+
+
+
+
+
+yyunlex(chr, val, loc)
+
+int chr;
+
+YYSTYPE val;
+
+YYLTYPE loc;
+
+{
+
+  yyunchar[yynunlexed] = chr;
+
+  yyunval[yynunlexed] = val;
+
+  yyunloc[yynunlexed] = loc;
+
+  yynunlexed++;
+
+}
+
+
+
+
+
+
+
+yyrestore(first, last)
+
+register short *first;
+
+register short *last;
+
+{
+
+  register short *ssp;
+
+  register short *rp;
+
+  register int symbol;
+
+  register int state;
+
+  register int tvalsaved;
+
+
+
+  ssp = yygssp;
+
+  yyunlex(yychar, yylval, yylloc);
+
+
+
+  tvalsaved = 0;
+
+  while (first != last)
+
+    {
+
+      symbol = yystos[*ssp];
+
+      if (symbol < YYNTBASE)
+
+	{
+
+	  yyunlex(symbol, yytval, yytloc);
+
+	  tvalsaved = 1;
+
+	  ssp--;
+
+	}
+
+
+
+      ssp--;
+
+
+
+      if (first == yyrq)
+
+	first = yyrq + YYMAXRULES;
+
+
+
+      first--;
+
+
+
+      for (rp = yyrhs + yyprhs[*first]; symbol = *rp; rp++)
+
+	{
+
+	  if (symbol < YYNTBASE)
+
+	    state = yytable[yypact[*ssp] + symbol];
+
+	  else
+
+	    {
+
+	      state = yypgoto[symbol - YYNTBASE] + *ssp;
+
+
+
+	      if (state >= 0 && state <= YYLAST && yycheck[state] == *ssp)
+
+		state = yytable[state];
+
+	      else
+
+		state = yydefgoto[symbol - YYNTBASE];
+
+	    }
+
+
+
+	  *++ssp = state;
+
+	}
+
+    }
+
+
+
+  if ( ! tvalsaved && ssp > yyss)
+
+    {
+
+      yyunlex(yystos[*ssp], yytval, yytloc);
+
+      ssp--;
+
+    }
+
+
+
+  yygssp = ssp;
+
+}
+
+
+
+
+
+
+
+int
+
+yyparse()
+
+{
+
+  register int yystate;
+
+  register int yyn;
+
+  register short *yyssp;
+
+  register short *yyrq0;
+
+  register short *yyptr;
+
+  register YYSTYPE *yyvsp;
+
+
+
+  int yylen;
+
+  YYLTYPE *yylsp;
+
+  short *yyrq1;
+
+  short *yyrq2;
+
+
+
+  yystate = 0;
+
+  yyssp = yyss - 1;
+
+  yyvsp = yyvs - 1;
+
+  yylsp = yyls - 1;
+
+  yyrq0 = yyrq;
+
+  yyrq1 = yyrq0;
+
+  yyrq2 = yyrq0;
+
+
+
+  yychar = yylex();
+
+  if (yychar < 0)
+
+    yychar = 0;
+
+  else yychar = YYTRANSLATE(yychar);
+
+
+
+yynewstate:
+
+
+
+  if (yyssp >= yyss + YYMAXDEPTH - 1)
+
+    {
+
+      yyabort("Parser Stack Overflow");
+
+      YYABORT;
+
+    }
+
+
+
+  *++yyssp = yystate;
+
+
+
+yyresume:
+
+
+
+  yyn = yypact[yystate];
+
+  if (yyn == YYFLAG)
+
+    goto yydefault;
+
+
+
+  yyn += yychar;
+
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar)
+
+    goto yydefault;
+
+
+
+  yyn = yytable[yyn];
+
+  if (yyn < 0)
+
+    {
+
+      yyn = -yyn;
+
+      goto yyreduce;
+
+    }
+
+  else if (yyn == 0)
+
+    goto yyerrlab;
+
+
+
+  yystate = yyn;
+
+
+
+  yyptr = yyrq2;
+
+  while (yyptr != yyrq1)
+
+    {
+
+      yyn = *yyptr++;
+
+      yylen = yyr2[yyn];
+
+      yyvsp -= yylen;
+
+      yylsp -= yylen;
+
+
+
+      yyguard(yyn, yyvsp, yylsp);
+
+      if (yyerror)
+
+	goto yysemerr;
+
+
+
+      yyaction(yyn, yyvsp, yylsp);
+
+      *++yyvsp = yyval;
+
+
+
+      yylsp++;
+
+      if (yylen == 0)
+
+	{
+
+	  yylsp->timestamp = timeclock;
+
+	  yylsp->first_line = yytloc.first_line;
+
+	  yylsp->first_column = yytloc.first_column;
+
+	  yylsp->last_line = (yylsp-1)->last_line;
+
+	  yylsp->last_column = (yylsp-1)->last_column;
+
+	  yylsp->text = 0;
+
+	}
+
+      else
+
+	{
+
+	  yylsp->last_line = (yylsp+yylen-1)->last_line;
+
+	  yylsp->last_column = (yylsp+yylen-1)->last_column;
+
+	}
+
+	  
+
+      if (yyptr == yyrq + YYMAXRULES)
+
+        yyptr = yyrq;
+
+    }
+
+
+
+  if (yystate == YYFINAL)
+
+    YYACCEPT;
+
+
+
+  yyrq2 = yyptr;
+
+  yyrq1 = yyrq0;
+
+
+
+  *++yyvsp = yytval;
+
+  *++yylsp = yytloc;
+
+  yytval = yylval;
+
+  yytloc = yylloc;
+
+  yyget();
+
+
+
+  goto yynewstate;
+
+
+
+yydefault:
+
+
+
+  yyn = yydefact[yystate];
+
+  if (yyn == 0)
+
+    goto yyerrlab;
+
+
+
+yyreduce:
+
+
+
+  *yyrq0++ = yyn;
+
+
+
+  if (yyrq0 == yyrq + YYMAXRULES)
+
+    yyrq0 = yyrq;
+
+
+
+  if (yyrq0 == yyrq2)
+
+    {
+
+      yyabort("Parser Rule Queue Overflow");
+
+      YYABORT;
+
+    }
+
+
+
+  yyssp -= yyr2[yyn];
+
+  yyn = yyr1[yyn];
+
+
+
+  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+
+  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+
+    yystate = yytable[yystate];
+
+  else
+
+    yystate = yydefgoto[yyn - YYNTBASE];
+
+
+
+  goto yynewstate;
+
+
+
+yysemerr:
+
+  *--yyptr = yyn;
+
+  yyrq2 = yyptr;
+
+  yyvsp += yyr2[yyn];
+
+
+
+yyerrlab:
+
+
+
+  yygssp = yyssp;
+
+  yygvsp = yyvsp;
+
+  yyglsp = yylsp;
+
+  yyrestore(yyrq0, yyrq2);
+
+  yyrecover();
+
+  yystate = *yygssp;
+
+  yyssp = yygssp;
+
+  yyvsp = yygvsp;
+
+  yyrq0 = yyrq;
+
+  yyrq1 = yyrq0;
+
+  yyrq2 = yyrq0;
+
+  goto yyresume;
+
+}
+
+
+
+$
+