From 2e507e65b7b0069e084843864b299e3b790608c3 Mon Sep 17 00:00:00 2001 From: Kolan Sh Date: Thu, 7 Apr 2011 17:03:45 +0400 Subject: [PATCH] =?UTF-8?q?=D0=BA=D1=83=D1=87=D0=B0=20=D0=B2=D1=81=D0=B5?= =?UTF-8?q?=D0=B3=D0=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bash/backup/backup_all | 4 + bash/backup/backup_lin | 21 + bash/backup/backup_win | 21 + bash/backup/crontab.conf | 4 + bash/bff/1.bff | 1 + bash/bff/1.out | 1 + bash/bff/1.txt | 1 + bash/bff/2.out | 1 + bash/bff/3.bff | 4 + bash/bff/3.out | Bin 0 -> 9 bytes bash/bff/4.bff | 1 + bash/bff/5.bff | 1 + bash/bff/bf2c.sh | 33 + bash/bff/hello.bff | 1 + bash/bff/kt2bf | Bin 0 -> 33060 bytes bash/bff/kt2bf.cpp | 215 ++++ bash/bff/out2.txt | 1 + bash/bff/t2bf | Bin 0 -> 8094 bytes bash/bff/t2bf.c | 107 ++ bash/bff/t2bf.c.klmn-0 | 107 ++ bash/bff/t2bf.c~ | 107 ++ bash/bff/test1.bff | 1 + bash/bff/test3.bff | 5 + bash/bff/text2bf.c | 40 + bash/bff/text2bf.lex.c | 1771 +++++++++++++++++++++++++++++++++ bash/bff/text2bf.lex.l | 40 + bash/cpu/cpu.sh | 15 + bash/ftp/ipftp.txt | 5 + bash/getopt/getopt_ex.sh | 0 bash/gprs/wvdial/beeline1 | 41 + bash/gprs/wvdial/megafon1 | 41 + bash/gprs/wvdial/megafon2 | 41 + bash/gprs/wvdial/megafon3 | 41 + bash/gprs/wvdial/megafon4 | 41 + bash/trap/trap.sh | 7 + bash/xml/xmlstarlet/file.xml | 7 + cpp/boost/yAx/.ccc.swp | Bin 0 -> 12288 bytes cpp/boost/yAx/aaa | 22 + cpp/boost/yAx/bbb | 22 + cpp/boost/yAx/ccc | 22 + cpp/boost/yAx/lu | Bin 0 -> 150501 bytes cpp/boost/yAx/lu.cpp | 22 + cpp/boost/yAx/rnd | Bin 0 -> 18691 bytes cpp/boost/yAx/rnd.cpp | 30 + cpp/boost/yAx/yAx | Bin 0 -> 51389 bytes cpp/boost/yAx/yAx.cpp | 19 + cpp/const_ul/cont_ul | Bin 0 -> 8358 bytes cpp/const_ul/cont_ul.cpp | 19 + cpp/recpath/recpath.cpp | 46 + cpp/static_map/static_map | Bin 0 -> 15354 bytes cpp/static_map/static_map.cpp | 25 + 51 files changed, 2954 insertions(+) create mode 100755 bash/backup/backup_all create mode 100755 bash/backup/backup_lin create mode 100755 bash/backup/backup_win create mode 100644 bash/backup/crontab.conf create mode 100644 bash/bff/1.bff create mode 100644 bash/bff/1.out create mode 100644 bash/bff/1.txt create mode 100644 bash/bff/2.out create mode 100644 bash/bff/3.bff create mode 100644 bash/bff/3.out create mode 100644 bash/bff/4.bff create mode 100644 bash/bff/5.bff create mode 100755 bash/bff/bf2c.sh create mode 100644 bash/bff/hello.bff create mode 100755 bash/bff/kt2bf create mode 100644 bash/bff/kt2bf.cpp create mode 100644 bash/bff/out2.txt create mode 100755 bash/bff/t2bf create mode 100644 bash/bff/t2bf.c create mode 100644 bash/bff/t2bf.c.klmn-0 create mode 100644 bash/bff/t2bf.c~ create mode 100644 bash/bff/test1.bff create mode 100644 bash/bff/test3.bff create mode 100644 bash/bff/text2bf.c create mode 100644 bash/bff/text2bf.lex.c create mode 100644 bash/bff/text2bf.lex.l create mode 100755 bash/cpu/cpu.sh create mode 100644 bash/ftp/ipftp.txt create mode 100755 bash/getopt/getopt_ex.sh create mode 100644 bash/gprs/wvdial/beeline1 create mode 100644 bash/gprs/wvdial/megafon1 create mode 100644 bash/gprs/wvdial/megafon2 create mode 100644 bash/gprs/wvdial/megafon3 create mode 100644 bash/gprs/wvdial/megafon4 create mode 100755 bash/trap/trap.sh create mode 100644 bash/xml/xmlstarlet/file.xml create mode 100644 cpp/boost/yAx/.ccc.swp create mode 100644 cpp/boost/yAx/aaa create mode 100644 cpp/boost/yAx/bbb create mode 100644 cpp/boost/yAx/ccc create mode 100755 cpp/boost/yAx/lu create mode 100644 cpp/boost/yAx/lu.cpp create mode 100755 cpp/boost/yAx/rnd create mode 100644 cpp/boost/yAx/rnd.cpp create mode 100755 cpp/boost/yAx/yAx create mode 100644 cpp/boost/yAx/yAx.cpp create mode 100755 cpp/const_ul/cont_ul create mode 100644 cpp/const_ul/cont_ul.cpp create mode 100644 cpp/recpath/recpath.cpp create mode 100755 cpp/static_map/static_map create mode 100644 cpp/static_map/static_map.cpp diff --git a/bash/backup/backup_all b/bash/backup/backup_all new file mode 100755 index 0000000..6d5166f --- /dev/null +++ b/bash/backup/backup_all @@ -0,0 +1,4 @@ +#!/bin/bash + +#/root/backup_lin +#/root/backup_win diff --git a/bash/backup/backup_lin b/bash/backup/backup_lin new file mode 100755 index 0000000..5aca582 --- /dev/null +++ b/bash/backup/backup_lin @@ -0,0 +1,21 @@ +#!/bin/bash +# backups all files in Debian root dir +#bkpdir=/root/penek4_bkp +# Если примонтировать директорию для бакапов в последний раз не удалось, +# то удаляем файлы бакапов, созданные на локальном диске +#rm -f ${bkpdir}/*.deb.tgz + +#/usr/bin/fusesmb /root/smb +#bkpdir=/root/smb/MSHOME/BACKBONE/penek4_bkp +bkpdir=/root/penek4_bkp +##smbmount //backbone/penek4_bkp ${bkpdir} -o username=guest,password=guest +#sleep 5 + +for dir in bin boot etc home initrd lib opt root sbin usr var; do + mv -f "${bkpdir}/${dir}.deb.tgz" "${bkpdir}/${dir}.deb.tgz~" + tar cvz --one-file-system -f "${bkpdir}/${dir}.deb.tgz" "/${dir}" + rm -f "${bkpdir}/${dir}.deb.tgz~" +done; +#umount /root/smb +##smbumount ${bkpdir} +#sleep 5 diff --git a/bash/backup/backup_win b/bash/backup/backup_win new file mode 100755 index 0000000..d9d8b45 --- /dev/null +++ b/bash/backup/backup_win @@ -0,0 +1,21 @@ +#!/bin/bash +# backups all files in Windows root dir +#bkpdir=/root/penek4_bkp +#Если в последний раз smbmount не сработала +#rm -f $bkpdir/*.xp.tgz + +#/usr/bin/fusesmb /root/smb +#bkpdir=/root/smb/MSHOME/BACKBONE/penek4_bkp +bkpdir=/root/penek4_bkp +##smbmount //backbone/penek4_bkp ${bkpdir} -o username=guest,password=guest +##sleep 5 + +for dir in "WINDOWS"; do + mv -f "$bkpdir/$dir.xp.tgz" "$bkpdir/$dir.xp.tgz~" + tar cvz --one-file-system -f "$bkpdir/$dir.xp.tgz" "/won/$dir" + rm -f "$bkpdir/$dir.xp.tgz~" +done + +#umount /root/smb +##smbumount ${bkpdir} +#sleep 5 diff --git a/bash/backup/crontab.conf b/bash/backup/crontab.conf new file mode 100644 index 0000000..1f19a08 --- /dev/null +++ b/bash/backup/crontab.conf @@ -0,0 +1,4 @@ +SHELL=/bin/bash +MAILTO=root +00 7 */3 * * (/root/backup_all >/dev/null 2>&1)& +00 */3 * * * (/usr/local/sbin/Update >/root/Update.log 2>&1)& diff --git a/bash/bff/1.bff b/bash/bff/1.bff new file mode 100644 index 0000000..9f9df82 --- /dev/null +++ b/bash/bff/1.bff @@ -0,0 +1 @@ +++++++++++[>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++<<<<<<<<<<<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.--------.+++.------.--------.-------------------------------------------------------------------.-----------------------. diff --git a/bash/bff/1.out b/bash/bff/1.out new file mode 100644 index 0000000..f14c363 --- /dev/null +++ b/bash/bff/1.out @@ -0,0 +1 @@ +++++++++++[>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++>+++++++++++++++++++++++++<<<<<<<<<<<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.--------------------------------.++++++++++++++++++++++++++++++++.-------------------------------.+++++++++++++++++++++++++++++++.------------------------------.++++++++++++++++++++++++++++++.-----------------------------.+++++++++++++++++++++++++++++.----------------------------.--------------------------------------------------------------------------------------------------------------------------------------------------------------------------. diff --git a/bash/bff/1.txt b/bash/bff/1.txt new file mode 100644 index 0000000..18a4378 --- /dev/null +++ b/bash/bff/1.txt @@ -0,0 +1 @@ +++++++++++[>>+<<-]>--------.>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<.>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>-------------------------------------------------------------------------------.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<.>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<.>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<.>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<. diff --git a/bash/bff/2.out b/bash/bff/2.out new file mode 100644 index 0000000..00f4706 --- /dev/null +++ b/bash/bff/2.out @@ -0,0 +1 @@ +абвгд diff --git a/bash/bff/3.bff b/bash/bff/3.bff new file mode 100644 index 0000000..5c46b10 --- /dev/null +++ b/bash/bff/3.bff @@ -0,0 +1,4 @@ +++[>++[>++[>++[>++[>+++<-] <-] <-] <-] <-] >>>>>+. <+[>+<-] >. <+[>+<-] >. +<+++++++++++++[>++++++++++++<-] >+. . . +<+++++++++++++++++++++++++++++++++++++++++++++++++++++[>---<-] >. <+[>+<-] >. +<+[>+<-] >. diff --git a/bash/bff/3.out b/bash/bff/3.out new file mode 100644 index 0000000000000000000000000000000000000000..bd811ec6c9d91c4b75abd767c2648003e43834cf GIT binary patch literal 9 QcmYdHN@ieSNK8rw01JTvO#lD@ literal 0 HcmV?d00001 diff --git a/bash/bff/4.bff b/bash/bff/4.bff new file mode 100644 index 0000000..73cb319 --- /dev/null +++ b/bash/bff/4.bff @@ -0,0 +1 @@ +++[>++[>++[>++[>++[>+++++++<-] <-] <-] <-] <-] >>>>>. diff --git a/bash/bff/5.bff b/bash/bff/5.bff new file mode 100644 index 0000000..c37cbec --- /dev/null +++ b/bash/bff/5.bff @@ -0,0 +1 @@ +++[>++[>++[>++[>++<-] <-] <-] <-] >>>><+++++[>++++++++<-] >. <+++++++[>++++<-] >+. <+++[>++<-] >+. . <++[>+<-] >+. <+++++++++++[>------<-] >-. <+++[>----<-] >. <+++++++++++++++++++++++++++++[>+++<-] >. <++[>----<-] >. <++[>+<-] >+. <+++[>--<-] >. <++[>----<-] >. <+++++++++++[>------<-] >-. <+++++++[>+++++++++++++++++++++++++<-] >. <++[>----------------<-] >. diff --git a/bash/bff/bf2c.sh b/bash/bff/bf2c.sh new file mode 100755 index 0000000..2ac54d3 --- /dev/null +++ b/bash/bff/bf2c.sh @@ -0,0 +1,33 @@ +#!/bin/awk -f +# a brainfuck to C translator. +# Needs a recent version of gawk, if on OS X, +# try using Fink's version. +# +# steve jenson + +BEGIN { + print "#include \n"; + print "int main() {"; + print " int c = 0;"; + print " static int b[30000];\n"; +} + +{ + #Note: the order in which these are + #substituted is very important. + gsub(/\]/, " }\n"); + gsub(/\[/, " while(b[c] != 0) {\n"); + gsub(/\+/, " ++b[c];\n"); + gsub(/\-/, " --b[c];\n"); + gsub(/>/, " ++c;\n"); + gsub(/ +++++ ++ add 7 to cell #1 > +++++ +++++ add 10 to cell #2 > +++ add 3 to cell #3 > + add 1 to cell #4 <<<< - decrement counter (cell #0) ] > ++ . print 'H' > + . print 'e' +++++ ++ . print 'l' . print 'l' +++ . print 'o' > ++ . print ' ' << +++++ +++++ +++++ . print 'W' > . print 'o' +++ . print 'r' ----- - . print 'l' ----- --- . print 'd' > + . print '!' > . print '\n' \ No newline at end of file diff --git a/bash/bff/kt2bf b/bash/bff/kt2bf new file mode 100755 index 0000000000000000000000000000000000000000..9d29c026337063b7a88082199992b860a44436e8 GIT binary patch literal 33060 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 yEho>)lUfGPQ+buiOrtz?HOX~6 +#include +#include +#include +#include +#include +typedef unsigned char UCHAR; +using namespace std; +//--------------------------------------------------------------------------- + +string sCode; + +// +vector fucktorize(int numm) +{ + if (numm == 1) { + vector v; + v.push_back(1); + return v; + } + + int newnum = numm; + vector newtext; + int checker = 2; // First possible factor to check + + while (checker *checker <= newnum) + if (newnum % checker == 0) { + newtext.push_back(checker); + newnum = newnum / checker; + + } else + checker++; + + if (newnum != 1) + newtext.push_back(newnum); + + return newtext; +} + +// fuck funcktors... =) +void fuckfucktors(const vector& fucktors, const int i, UCHAR op = 0) +{ + if (op == 0) + op = '+'; + + UCHAR notop = (op == '+') ? '-' : '+'; + + if (i != 0) + sCode += "[>"; + + UCHAR tmpop; + + if (i != (int)fucktors.size() - 1) + tmpop = '+'; + + else + tmpop = op; + + for (int j = 1; j <= fucktors[i]; j++) + sCode += tmpop; + + if (i + 1 < (int)fucktors.size()) + fuckfucktors(fucktors, i + 1, op); + + if (i != 0) + sCode += "<-] "; +} + +int min_val(const string& s) +{ + if (s == "") + return -1; + + int m = (UCHAR)s[0]; + + for (size_t i = 1, max_i = s.size(); i < max_i; i++) + if (m > (UCHAR)s[i]) + m = (UCHAR)s[i]; + + return m; +} + +int max_val(const string& s) +{ + if (s == "") + return -1; + + int m = (UCHAR)s[0]; + + for (size_t i = 1, max_i = s.size(); i < max_i; i++) + if (m < (UCHAR)s[i]) + m = (UCHAR)s[i]; + + return m; +} + +// , - .) +string brainfuckit(const string &str) +{ + string aStr, aStrPrinted; + sCode = ""; + + if (str == "") + return ""; + + for (size_t i = 0, max_i = str.length(); i < max_i; i++) + aStr += str[i]; + + int iMinvalue = min_val(aStr); // *std::min_element(aStr.begin(), aStr.end()); + vector fucktors = fucktorize(iMinvalue); + int residuo = 0; + + if (fucktors.size() == 1) { + fucktors = fucktorize(iMinvalue - 1); + residuo = 1; + } + + fuckfucktors(fucktors, 0); + sCode += " "; + + for (size_t i = 0, max_i = fucktors.size() - 1; i < max_i; i++) + sCode += ">"; + + for (int i = 0; i < residuo; i++) + sCode += "+"; + + for (size_t i = 0, max_i = aStr.length(); i < max_i; i++) { + + if ((UCHAR)aStr[i] == iMinvalue) { + sCode += ". "; + continue; + } + + if ((UCHAR)aStr[i] < iMinvalue) { + int x = iMinvalue - (UCHAR)aStr[i]; + vector ff = fucktorize(x); + int res = 0; + + if ((ff.size() == 1) && (x != 1)) { + x = x - 1; + ff = fucktorize(x); + res = 1; + } + + int maxFucktor = *std::max_element(ff.begin(), ff.end()); + int complement = x / maxFucktor; + sCode += '<'; + + vector tmp_v; + tmp_v.push_back(maxFucktor); + tmp_v.push_back(complement); + + fuckfucktors(tmp_v, 0, '-'); + sCode += ">"; + + for (int k = 0; k < res; k++) + sCode += "-"; + + sCode += ". "; + iMinvalue -= iMinvalue - (UCHAR)aStr[i]; + continue; + } + + if ((UCHAR)aStr[i] > iMinvalue) { + int x = (UCHAR)aStr[i] - iMinvalue; + vector ff = fucktorize(x); + int res = 0; + + if ((ff.size() == 1) && (x != 1)) { + x = x - 1; + ff = fucktorize(x); + res = 1; + } + + int maxFucktor = *std::max_element(ff.begin(), ff.end()); + int complement = x / maxFucktor; + sCode += '<'; + + vector tmp_v; + tmp_v.push_back(maxFucktor); + tmp_v.push_back(complement); + + fuckfucktors(tmp_v, 0, '+'); + sCode += ">"; + + for (int k = 0; k < res; k++) + sCode += "+"; + + sCode += ". "; + iMinvalue += (UCHAR)aStr[i] - iMinvalue; + continue; + } + } + + return sCode; +} + +int main(int argc, char *argv[]) +{ + if (argc != 2) { + cout << "Need string as a parameter to program" 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 Gi+=(<(iQ^% literal 0 HcmV?d00001 diff --git a/bash/bff/t2bf.c b/bash/bff/t2bf.c new file mode 100644 index 0000000..ed8a1c8 --- /dev/null +++ b/bash/bff/t2bf.c @@ -0,0 +1,107 @@ +/* + * Brainfuck String Generator Generator + * A program which takes a string and + * generates a brainfuck code which + * generates the string + * written by the legend: Amir Watad (dot com) + */ +#include +#include +#define N 26 +#define MAX_STR_LEN 100000 +int main(int argc, char *argv[]) +{ + unsigned char used[N] = {[0 ... N-1] = -1}; /* saves the state of the +brainfuck array */ + unsigned char map[N] = {[0 ... N-1] = -1}; /* a map for fast access to +relevant cells + in the brainfuck array */ + unsigned char string[MAX_STR_LEN]; /* input string with a newline in the end */ + unsigned char str[MAX_STR_LEN]; /* input string */ + int used_idx = 0; /* current place of the brainfuck pointer */ + int str_idx = 0; /* index of current unsigned char in the string */ + unsigned char current; /* current unsigned char */ + int i, j; /* general purpose iterators */ + unsigned char c; + if (argc == 2) { + strcpy(str, argv[1]); + } else if (argc == 1) { + i = 0; + while (((c = getchar()) != EOF) && i < MAX_STR_LEN) { + str[i] = c; + i++; + } + } else { + printf("bad number of arguments\n"); + return 0; + } + /* copy the input string + a newline */ + strcpy(string, str); + string[strlen(str)] = '\n'; + string[strlen(str)+1] = '\0'; + + /* we'll use first index as a counter for the while loop */ + used[0] = 10; + printf("++++++++++["); + used_idx = 1; + + /* prepare a few places in the brainfuck array + * with values close to those of the unsigned characters + * in the string */ + while (current = string[str_idx]) { + if (map[current/10] == -1) { + used[used_idx] = (current/10)*10; + map[current/10] = used_idx; + used_idx++; + } + str_idx++; + } + + str_idx = 0; + + /* fill the brainfuck array with initial values */ + for (i = 1; i < N; i++) { + if (used[i] == -1) + break; + printf(">"); + for (j = 0; j < used[i]/10; j++) + printf("+"); + } + + for (i = 1; i < N; i++) { + if (used[i] == -1) + break; + printf("<"); + } + printf("-]"); + used_idx = 0; + + while (current = string[str_idx]) { + int relevant_idx = map[current/10]; + int diff_idx = relevant_idx - used_idx; + int val = used[relevant_idx]; + int diff_val = current - val; + used_idx = relevant_idx; + if (diff_idx > 0) + for (i = 0; i < diff_idx; i++) + printf(">"); + else + for (i = 0; i > diff_idx; i--) + printf("<"); + if (diff_val > 0) + for (i = 0; i < diff_val; i++) { + printf("+"); + used[used_idx]++; + } + else + for (i = 0; i > diff_val; i--) { + printf("-"); + used[used_idx]--; + } + printf("."); + str_idx++; + } + printf("\n"); + return 1; +} + diff --git a/bash/bff/t2bf.c.klmn-0 b/bash/bff/t2bf.c.klmn-0 new file mode 100644 index 0000000..0863d9c --- /dev/null +++ b/bash/bff/t2bf.c.klmn-0 @@ -0,0 +1,107 @@ +/* + * Brainfuck String Generator Generator + * A program which takes a string and + * generates a brainfuck code which + * generates the string + * written by the legend: Amir Watad (dot com) + */ +#include +#include +#define N 26 +#define MAX_STR_LEN 100000 +int main(int argc, char *argv[]) +{ + char used[N] = {[0 ... N-1] = -1}; /* saves the state of the +brainfuck array */ + char map[N] = {[0 ... N-1] = -1}; /* a map for fast access to +relevant cells + in the brainfuck array */ + char string[MAX_STR_LEN]; /* input string with a newline in the end */ + char str[MAX_STR_LEN]; /* input string */ + int used_idx = 0; /* current place of the brainfuck pointer */ + int str_idx = 0; /* index of current char in the string */ + char current; /* current char */ + int i, j; /* general purpose iterators */ + char c; + if (argc == 2) { + strcpy(str, argv[1]); + } else if (argc == 1) { + i = 0; + while (((c = getchar()) != EOF) && i < MAX_STR_LEN) { + str[i] = c; + i++; + } + } else { + printf("bad number of arguments\n"); + return 0; + } + /* copy the input string + a newline */ + strcpy(string, str); + string[strlen(str)] = '\n'; + string[strlen(str)+1] = '\0'; + + /* we'll use first index as a counter for the while loop */ + used[0] = 10; + printf("++++++++++["); + used_idx = 1; + + /* prepare a few places in the brainfuck array + * with values close to those of the characters + * in the string */ + while (current = string[str_idx]) { + if (map[current/10] == -1) { + used[used_idx] = (current/10)*10; + map[current/10] = used_idx; + used_idx++; + } + str_idx++; + } + + str_idx = 0; + + /* fill the brainfuck array with initial values */ + for (i = 1; i < N; i++) { + if (used[i] == -1) + break; + printf(">"); + for (j = 0; j < used[i]/10; j++) + printf("+"); + } + + for (i = 1; i < N; i++) { + if (used[i] == -1) + break; + printf("<"); + } + printf("-]"); + used_idx = 0; + + while (current = string[str_idx]) { + int relevant_idx = map[current/10]; + int diff_idx = relevant_idx - used_idx; + int val = used[relevant_idx]; + int diff_val = current - val; + used_idx = relevant_idx; + if (diff_idx > 0) + for (i = 0; i < diff_idx; i++) + printf(">"); + else + for (i = 0; i > diff_idx; i--) + printf("<"); + if (diff_val > 0) + for (i = 0; i < diff_val; i++) { + printf("+"); + used[used_idx]++; + } + else + for (i = 0; i > diff_val; i--) { + printf("-"); + used[used_idx]--; + } + printf("."); + str_idx++; + } + printf("\n"); + return 1; +} + diff --git a/bash/bff/t2bf.c~ b/bash/bff/t2bf.c~ new file mode 100644 index 0000000..a7a15ac --- /dev/null +++ b/bash/bff/t2bf.c~ @@ -0,0 +1,107 @@ +/* + * Brainfuck String Generator Generator + * A program which takes a string and + * generates a brainfuck code which + * generates the string + * written by the legend: Amir Watad (dot com) + */ +#include +#include +#define N 26 +#define MAX_STR_LEN 100000 +int main(int argc, char *argv[]) +{ + unsigned char used[N] = {[0 ... N-1] = -1}; /* saves the state of the +brainfuck array */ + unsigned char map[N] = {[0 ... N-1] = -1}; /* a map for fast access to +relevant cells + in the brainfuck array */ + unsigned char string[MAX_STR_LEN]; /* input string with a newline in the end */ + unsigned char str[MAX_STR_LEN]; /* input string */ + int used_idx = 0; /* current place of the brainfuck pointer */ + int str_idx = 0; /* index of current unsigned char in the string */ + unsigned char current; /* current unsigned char */ + int i, j; /* general purpose iterators */ + unsigned char c; + if (argc == 2) { + strcpy(str, argv[1]); + } else if (argc == 1) { + i = 0; + while (((c = get (unsigned char())) != EOF) && i < MAX_STR_LEN) { + str[i] = c; + i++; + } + } else { + printf("bad number of arguments\n"); + return 0; + } + /* copy the input string + a newline */ + strcpy(string, str); + string[strlen(str)] = '\n'; + string[strlen(str)+1] = '\0'; + + /* we'll use first index as a counter for the while loop */ + used[0] = 10; + printf("++++++++++["); + used_idx = 1; + + /* prepare a few places in the brainfuck array + * with values close to those of the unsigned characters + * in the string */ + while (current = string[str_idx]) { + if (map[current/10] == -1) { + used[used_idx] = (current/10)*10; + map[current/10] = used_idx; + used_idx++; + } + str_idx++; + } + + str_idx = 0; + + /* fill the brainfuck array with initial values */ + for (i = 1; i < N; i++) { + if (used[i] == -1) + break; + printf(">"); + for (j = 0; j < used[i]/10; j++) + printf("+"); + } + + for (i = 1; i < N; i++) { + if (used[i] == -1) + break; + printf("<"); + } + printf("-]"); + used_idx = 0; + + while (current = string[str_idx]) { + int relevant_idx = map[current/10]; + int diff_idx = relevant_idx - used_idx; + int val = used[relevant_idx]; + int diff_val = current - val; + used_idx = relevant_idx; + if (diff_idx > 0) + for (i = 0; i < diff_idx; i++) + printf(">"); + else + for (i = 0; i > diff_idx; i--) + printf("<"); + if (diff_val > 0) + for (i = 0; i < diff_val; i++) { + printf("+"); + used[used_idx]++; + } + else + for (i = 0; i > diff_val; i--) { + printf("-"); + used[used_idx]--; + } + printf("."); + str_idx++; + } + printf("\n"); + return 1; +} + diff --git a/bash/bff/test1.bff b/bash/bff/test1.bff new file mode 100644 index 0000000..d8cde7e --- /dev/null +++ b/bash/bff/test1.bff @@ -0,0 +1 @@ +++++++++++[>>>++++>+++>+++++++++++>++++++++++>+<<<<<<<-]>--------.<-----------------------------------------------------------------------------------------------------------.>+.>--------.<-.<<<<<<<<<<<<<<<<<<<<<<<<-----------------------------------------------------------------------.>>>>>>>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<<<<<<<<<<<<<<------.>>>>>>>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<<<<<<<<<<<<<<+++.>>>>>>>>>>>>>>>>>>>>>>>>+.>++.>++++.>++.>+++++++++.--------.+++.>++++++++.--------.<<+.>>>. \ No newline at end of file diff --git a/bash/bff/test3.bff b/bash/bff/test3.bff new file mode 100644 index 0000000..4f2a62d --- /dev/null +++ b/bash/bff/test3.bff @@ -0,0 +1,5 @@ +>++++++++++ +[>++++>++++>+++++>+++++>++++++>+++++>++++++>++++>++++>+++++>+++++>++++++>+++++>++++++>++++>++++>+++++>+++++>++++++>+++++>++++++>++++>++++>+++++>+++++>++++++>+++++>++++++>++++>++++>+++++>+++++>++++++>+++++>++++++><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<-] +>-->----->->-->----->>->-->----->->-->----->+>->-->----->->-->----->++>->-->----->->-->----->+++>->-->----->->-->----->++++>-> +<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< +>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>. diff --git a/bash/bff/text2bf.c b/bash/bff/text2bf.c new file mode 100644 index 0000000..98efee7 --- /dev/null +++ b/bash/bff/text2bf.c @@ -0,0 +1,40 @@ +/* + text to brainfuck converter + -- saves any input text inside the brainfuck registers and prints it +all out. + + 2004-07-22 - BeF + + compile hint: + lex -o text2bf.lex.c text2bf.lex.l + cc -pipe -O2 text2bf.lex.c -o text2bf -ll +*/ +%{ +int prevchar = 0; +%} + +%% + +(.|\n) { + printf("<[->+>+<<]>>[-<<+>>]<"); + if (prevchar < yytext[0]) + while (yytext[0]-prevchar++) + putchar('+'); + else + while (yytext[0]-prevchar--) + putchar('-'); + putchar('>'); + prevchar = yytext[0]; + } + + +%% + +int main () +{ + int ret = yylex(); + printf("<[<]>[.>]\n"); + return ret; +} + + diff --git a/bash/bff/text2bf.lex.c b/bash/bff/text2bf.lex.c new file mode 100644 index 0000000..d1e8b2a --- /dev/null +++ b/bash/bff/text2bf.lex.c @@ -0,0 +1,1771 @@ +#line 2 "text2bf.lex.c" + +#line 4 "text2bf.lex.c" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 +#define YY_FLEX_SUBMINOR_VERSION 35 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; +#endif /* ! C99 */ + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#endif /* ! FLEXINT_H */ + +#ifdef __cplusplus + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +/* C99 requires __STDC__ to be defined as 1. */ +#if defined (__STDC__) + +#define YY_USE_CONST + +#endif /* defined (__STDC__) */ +#endif /* ! __cplusplus */ + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart(yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#define YY_BUF_SIZE 16384 +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +extern int yyleng; + +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) + +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart (FILE *input_file ); +void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); +void yy_delete_buffer (YY_BUFFER_STATE b ); +void yy_flush_buffer (YY_BUFFER_STATE b ); +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state (void ); + +static void yyensure_buffer_stack (void ); +static void yy_load_buffer_state (void ); +static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); + +#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); +YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); + +void *yyalloc (yy_size_t ); +void *yyrealloc (void *,yy_size_t ); +void yyfree (void * ); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer(yyin,YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer(yyin,YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ + +typedef unsigned char YY_CHAR; + +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; + +typedef int yy_state_type; + +extern int yylineno; + +int yylineno = 1; + +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state (void ); +static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); +static int yy_get_next_buffer (void ); +static void yy_fatal_error (yyconst char msg[] ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ + yyleng = (size_t) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; + +#define YY_NUM_RULES 2 +#define YY_END_OF_BUFFER 3 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static yyconst flex_int16_t yy_accept[6] = + { 0, + 0, 0, 3, 1, 0 + } ; + +static yyconst flex_int32_t yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst flex_int32_t yy_meta[3] = + { 0, + 1, 1 + } ; + +static yyconst flex_int16_t yy_base[6] = + { 0, + 0, 0, 3, 4, 4 + } ; + +static yyconst flex_int16_t yy_def[6] = + { 0, + 5, 1, 5, 5, 0 + } ; + +static yyconst flex_int16_t yy_nxt[7] = + { 0, + 4, 4, 5, 3, 5, 5 + } ; + +static yyconst flex_int16_t yy_chk[7] = + { 0, + 1, 1, 3, 5, 5, 5 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int yy_flex_debug; +int yy_flex_debug = 0; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "text2bf.lex.l" +/* + text to brainfuck converter + -- saves any input text inside the brainfuck registers and prints it +all out. + + 2004-07-22 - BeF + + compile hint: + lex -o text2bf.lex.c text2bf.lex.l + cc -pipe -O2 text2bf.lex.c -o text2bf -ll +*/ +#line 13 "text2bf.lex.l" +int prevchar = 0; +#line 463 "text2bf.lex.c" + +#define INITIAL 0 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +static int yy_init_globals (void ); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy (void ); + +int yyget_debug (void ); + +void yyset_debug (int debug_flag ); + +YY_EXTRA_TYPE yyget_extra (void ); + +void yyset_extra (YY_EXTRA_TYPE user_defined ); + +FILE *yyget_in (void ); + +void yyset_in (FILE * in_str ); + +FILE *yyget_out (void ); + +void yyset_out (FILE * out_str ); + +int yyget_leng (void ); + +char *yyget_text (void ); + +int yyget_lineno (void ); + +void yyset_lineno (int line_number ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap (void ); +#else +extern int yywrap (void ); +#endif +#endif + + static void yyunput (int c,char *buf_ptr ); + +#ifndef yytext_ptr +static void yy_flex_strncpy (char *,yyconst char *,int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * ); +#endif + +#ifndef YY_NO_INPUT + +#ifdef __cplusplus +static int yyinput (void ); +#else +static int input (void ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + int n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (void); + +#define YY_DECL int yylex (void) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 16 "text2bf.lex.l" + + +#line 648 "text2bf.lex.c" + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer(yyin,YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = (yy_start); +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 6 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 4 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +/* rule 1 can match eol */ +YY_RULE_SETUP +#line 18 "text2bf.lex.l" +{ + printf("<[->+>+<<]>>[-<<+>>]<"); + if (prevchar < yytext[0]) + while (yytext[0]-prevchar++) + putchar('+'); + else + while (yytext[0]-prevchar--) + putchar('-'); + putchar('>'); + prevchar = yytext[0]; + } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 31 "text2bf.lex.l" +ECHO; + YY_BREAK +#line 752 "text2bf.lex.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = (yy_c_buf_p); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ +} /* end of yylex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (void) +{ + register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + register char *source = (yytext_ptr); + register int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), (size_t) num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart(yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (void) +{ + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 6 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +{ + register int yy_is_jam; + register char *yy_cp = (yy_c_buf_p); + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 6 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 5); + + return yy_is_jam ? 0 : yy_current_state; +} + + static void yyunput (int c, register char * yy_bp ) +{ + register char *yy_cp; + + yy_cp = (yy_c_buf_p); + + /* undo effects of setting up yytext */ + *yy_cp = (yy_hold_char); + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = (yy_n_chars) + 2; + register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + register char *source = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + (yytext_ptr) = yy_bp; + (yy_hold_char) = *yy_cp; + (yy_c_buf_p) = yy_cp; +} + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (yy_c_buf_p) - (yytext_ptr); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart(yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return EOF; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer(yyin,YY_BUF_SIZE ); + } + + yy_init_buffer(YY_CURRENT_BUFFER,input_file ); + yy_load_buffer_state( ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +static void yy_load_buffer_state (void) +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer(b,file ); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree((void *) b->yy_ch_buf ); + + yyfree((void *) b ); +} + +#ifndef _UNISTD_H /* assume unistd.h has isatty() for us */ +#ifdef __cplusplus +extern "C" { +#endif +#ifdef __THROW /* this is a gnuism */ +extern int isatty (int ) __THROW; +#else +extern int isatty (int ); +#endif +#ifdef __cplusplus +} +#endif +#endif + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) + +{ + int oerrno = errno; + + yy_flush_buffer(b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void yypop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (void) +{ + int num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + int grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer(b ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) +{ + + return yy_scan_bytes(yystr,strlen(yystr) ); +} + +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param bytes the byte buffer to scan + * @param len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = _yybytes_len + 2; + buf = (char *) yyalloc(n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer(buf,n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yy_fatal_error (yyconst char* msg ) +{ + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} + +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} + +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} + +/** Get the length of the current token. + * + */ +int yyget_leng (void) +{ + return yyleng; +} + +/** Get the current token. + * + */ + +char *yyget_text (void) +{ + return yytext; +} + +/** Set the current line number. + * @param line_number + * + */ +void yyset_lineno (int line_number ) +{ + + yylineno = line_number; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * in_str ) +{ + yyin = in_str ; +} + +void yyset_out (FILE * out_str ) +{ + yyout = out_str ; +} + +int yyget_debug (void) +{ + return yy_flex_debug; +} + +void yyset_debug (int bdebug ) +{ + yy_flex_debug = bdebug ; +} + +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + (yy_buffer_stack) = 0; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = (char *) 0; + (yy_init) = 0; + (yy_start) = 0; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = (FILE *) 0; + yyout = (FILE *) 0; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} + +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } + + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( ); + + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) +{ + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * s ) +{ + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size ) +{ + return (void *) malloc( size ); +} + +void *yyrealloc (void * ptr, yy_size_t size ) +{ + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); +} + +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 31 "text2bf.lex.l" + + + +int main () +{ + int ret = yylex(); + printf("<[<]>[.>]\n"); + return ret; +} + + + diff --git a/bash/bff/text2bf.lex.l b/bash/bff/text2bf.lex.l new file mode 100644 index 0000000..98efee7 --- /dev/null +++ b/bash/bff/text2bf.lex.l @@ -0,0 +1,40 @@ +/* + text to brainfuck converter + -- saves any input text inside the brainfuck registers and prints it +all out. + + 2004-07-22 - BeF + + compile hint: + lex -o text2bf.lex.c text2bf.lex.l + cc -pipe -O2 text2bf.lex.c -o text2bf -ll +*/ +%{ +int prevchar = 0; +%} + +%% + +(.|\n) { + printf("<[->+>+<<]>>[-<<+>>]<"); + if (prevchar < yytext[0]) + while (yytext[0]-prevchar++) + putchar('+'); + else + while (yytext[0]-prevchar--) + putchar('-'); + putchar('>'); + prevchar = yytext[0]; + } + + +%% + +int main () +{ + int ret = yylex(); + printf("<[<]>[.>]\n"); + return ret; +} + + diff --git a/bash/cpu/cpu.sh b/bash/cpu/cpu.sh new file mode 100755 index 0000000..8dd33d2 --- /dev/null +++ b/bash/cpu/cpu.sh @@ -0,0 +1,15 @@ +#!/bin/bash +# cpu usage + +a=`cat /proc/stat|grep cpu|head -n1|sed -r 's/[0-9]+ [0-9]+ [0-9]+ [0-9]+ [0-9]+ [0-9]+ [0-9]+/Z&Z/'|cut -dZ -f2` +sleep 1 +b=`cat /proc/stat|grep cpu|head -n1|sed -r 's/[0-9]+ [0-9]+ [0-9]+ [0-9]+ [0-9]+ [0-9]+ [0-9]+/Z&Z/'|cut -dZ -f2` +sum=0 +for i in `seq 3`; do + s1="`echo $a|cut -d" " -f$i`" + s2="`echo $b|cut -d" " -f$i`" + sum=$sum+$s2-$s1 +done + +echo $sum|bc + diff --git a/bash/ftp/ipftp.txt b/bash/ftp/ipftp.txt new file mode 100644 index 0000000..ab84ab0 --- /dev/null +++ b/bash/ftp/ipftp.txt @@ -0,0 +1,5 @@ +open ftp.narod.ru +mkdir ifconfig +cd ifconfig +send ifconfig-backbone.txt +quit diff --git a/bash/getopt/getopt_ex.sh b/bash/getopt/getopt_ex.sh new file mode 100755 index 0000000..e69de29 diff --git a/bash/gprs/wvdial/beeline1 b/bash/gprs/wvdial/beeline1 new file mode 100644 index 0000000..c584ebb --- /dev/null +++ b/bash/gprs/wvdial/beeline1 @@ -0,0 +1,41 @@ +[Dialer defaults] +# Lines begining with # are comments. +# wvdial will look for this file at /etc/wvdial.conf or /home/LoginName/.wvdial.rc + +# Redhat/Fedora have an Internet Connection Wizard in the popup menus +# ICW will write a two part /etc/wvdial.conf supporting multiple modem usage. + +Modem = /home/kolan/.mobile_modem +Baud = 460000 +Init1 = ATZ +Init2 = AT+CGDCONT=1,"IP","internet.beeline.ru" +# ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0 +# Lack of dialtone acquisition can be due to low line voltage, +# a common problem in Italy. +# Try inserting a "dial without waiting": X3 +# Init2 = ATQ0 V1 E1 S0=0 X3 &C1 &D2 +FCLASS=0 +# In case of connection instabilities, specify a lower frequency: +# Init2 = ATQ0 V1 E1 S0=0 X3 &C1 &D2 +MS=34 +# ISDN = 0 +# Modem Type = Analog Modem +# Phone = *99***1# + Phone = 0679 +# if going through a switch board, a perhaps necessary pause can produced with a comma: +# Phone = 1,Dialout_phone_number +Username = beeline +# if Internet Provider is MSN.net, use under Linux: MSN/LoginName +Password = beeline + +# the following lines is NEEDED only by slmodemd +Carrier check = no +# Kinternet appears to add it automatically. + +## If CONNECT is achieved but browsing fails, try activating the following line + Auto DNS = yes +## To make a logfile wvdial.out + wvdial 2>&1 | tee wvdial.out +# # For some Internet providers, the following line is necessary + Stupid Mode = yes +## for other wvdial options, do "man wvdial" or see the documentation in +## /usr/share/doc/wvdial/ +## End wvdial.conf diff --git a/bash/gprs/wvdial/megafon1 b/bash/gprs/wvdial/megafon1 new file mode 100644 index 0000000..8dedc23 --- /dev/null +++ b/bash/gprs/wvdial/megafon1 @@ -0,0 +1,41 @@ +[Dialer defaults] +# Lines begining with # are comments. +# wvdial will look for this file at /etc/wvdial.conf or /home/LoginName/.wvdial.rc + +# Redhat/Fedora have an Internet Connection Wizard in the popup menus +# ICW will write a two part /etc/wvdial.conf supporting multiple modem usage. + +Modem = /home/kolan/.mobile_modem +Baud = 64000 +Init1 = ATZ +#Init2 = AT+CGDCONT=1,"IP","internet" +# ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0 +# Lack of dialtone acquisition can be due to low line voltage, +# a common problem in Italy. +# Try inserting a "dial without waiting": X3 +# Init2 = ATQ0 V1 E1 S0=0 X3 &C1 &D2 +FCLASS=0 +# In case of connection instabilities, specify a lower frequency: +# Init2 = ATQ0 V1 E1 S0=0 X3 &C1 &D2 +MS=34 +# ISDN = 0 +# Modem Type = Analog Modem +#Phone = *99# + Phone = *99***1# +# if going through a switch board, a perhaps necessary pause can produced with a comma: +# Phone = 1,Dialout_phone_number +Username = gdata +# if Internet Provider is MSN.net, use under Linux: MSN/LoginName +Password = gdata + +# the following lines is NEEDED only by slmodemd +Carrier check = no +# Kinternet appears to add it automatically. + +## If CONNECT is achieved but browsing fails, try activating the following line + Auto DNS = yes +## To make a logfile wvdial.out + wvdial 2>&1 | tee wvdial.out +# # For some Internet providers, the following line is necessary + Stupid Mode = yes +## for other wvdial options, do "man wvdial" or see the documentation in +## /usr/share/doc/wvdial/ +## End wvdial.conf diff --git a/bash/gprs/wvdial/megafon2 b/bash/gprs/wvdial/megafon2 new file mode 100644 index 0000000..2864cbd --- /dev/null +++ b/bash/gprs/wvdial/megafon2 @@ -0,0 +1,41 @@ +[Dialer defaults] +# Lines begining with # are comments. +# wvdial will look for this file at /etc/wvdial.conf or /home/LoginName/.wvdial.rc + +# Redhat/Fedora have an Internet Connection Wizard in the popup menus +# ICW will write a two part /etc/wvdial.conf supporting multiple modem usage. + +Modem = /home/kolan/.mobile_modem +Baud = 115200 +Init1 = ATZ +#Init2 = AT+CGDCONT=1,"IP","internet" +# ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0 +# Lack of dialtone acquisition can be due to low line voltage, +# a common problem in Italy. +# Try inserting a "dial without waiting": X3 +# Init2 = ATQ0 V1 E1 S0=0 X3 &C1 &D2 +FCLASS=0 +# In case of connection instabilities, specify a lower frequency: +# Init2 = ATQ0 V1 E1 S0=0 X3 &C1 &D2 +MS=34 +# ISDN = 0 +# Modem Type = Analog Modem +#Phone = *99# + Phone = *99***1# +# if going through a switch board, a perhaps necessary pause can produced with a comma: +# Phone = 1,Dialout_phone_number +Username = gdata +# if Internet Provider is MSN.net, use under Linux: MSN/LoginName +Password = gdata + +# the following lines is NEEDED only by slmodemd +Carrier check = no +# Kinternet appears to add it automatically. + +## If CONNECT is achieved but browsing fails, try activating the following line + Auto DNS = yes +## To make a logfile wvdial.out + wvdial 2>&1 | tee wvdial.out +# # For some Internet providers, the following line is necessary + Stupid Mode = yes +## for other wvdial options, do "man wvdial" or see the documentation in +## /usr/share/doc/wvdial/ +## End wvdial.conf diff --git a/bash/gprs/wvdial/megafon3 b/bash/gprs/wvdial/megafon3 new file mode 100644 index 0000000..a08898d --- /dev/null +++ b/bash/gprs/wvdial/megafon3 @@ -0,0 +1,41 @@ +[Dialer defaults] +# Lines begining with # are comments. +# wvdial will look for this file at /etc/wvdial.conf or /home/LoginName/.wvdial.rc + +# Redhat/Fedora have an Internet Connection Wizard in the popup menus +# ICW will write a two part /etc/wvdial.conf supporting multiple modem usage. + +Modem = /home/kolan/.mobile_modem +Baud = 230400 +Init1 = ATZ +#Init2 = AT+CGDCONT=1,"IP","internet" +# ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0 +# Lack of dialtone acquisition can be due to low line voltage, +# a common problem in Italy. +# Try inserting a "dial without waiting": X3 +# Init2 = ATQ0 V1 E1 S0=0 X3 &C1 &D2 +FCLASS=0 +# In case of connection instabilities, specify a lower frequency: +# Init2 = ATQ0 V1 E1 S0=0 X3 &C1 &D2 +MS=34 +# ISDN = 0 +# Modem Type = Analog Modem +#Phone = *99# + Phone = *99***1# +# if going through a switch board, a perhaps necessary pause can produced with a comma: +# Phone = 1,Dialout_phone_number +Username = gdata +# if Internet Provider is MSN.net, use under Linux: MSN/LoginName +Password = gdata + +# the following lines is NEEDED only by slmodemd +Carrier check = no +# Kinternet appears to add it automatically. + +## If CONNECT is achieved but browsing fails, try activating the following line + Auto DNS = yes +## To make a logfile wvdial.out + wvdial 2>&1 | tee wvdial.out +# # For some Internet providers, the following line is necessary + Stupid Mode = yes +## for other wvdial options, do "man wvdial" or see the documentation in +## /usr/share/doc/wvdial/ +## End wvdial.conf diff --git a/bash/gprs/wvdial/megafon4 b/bash/gprs/wvdial/megafon4 new file mode 100644 index 0000000..01dc559 --- /dev/null +++ b/bash/gprs/wvdial/megafon4 @@ -0,0 +1,41 @@ +[Dialer defaults] +# Lines begining with # are comments. +# wvdial will look for this file at /etc/wvdial.conf or /home/LoginName/.wvdial.rc + +# Redhat/Fedora have an Internet Connection Wizard in the popup menus +# ICW will write a two part /etc/wvdial.conf supporting multiple modem usage. + +Modem = /home/kolan/.mobile_modem +Baud =460800 +Init1 = ATZ +#Init2 = AT+CGDCONT=1,"IP","internet" +# ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0 +# Lack of dialtone acquisition can be due to low line voltage, +# a common problem in Italy. +# Try inserting a "dial without waiting": X3 +# Init2 = ATQ0 V1 E1 S0=0 X3 &C1 &D2 +FCLASS=0 +# In case of connection instabilities, specify a lower frequency: +# Init2 = ATQ0 V1 E1 S0=0 X3 &C1 &D2 +MS=34 +# ISDN = 0 +# Modem Type = Analog Modem +#Phone = *99# + Phone = *99***1# +# if going through a switch board, a perhaps necessary pause can produced with a comma: +# Phone = 1,Dialout_phone_number +Username = gdata +# if Internet Provider is MSN.net, use under Linux: MSN/LoginName +Password = gdata + +# the following lines is NEEDED only by slmodemd +Carrier check = no +# Kinternet appears to add it automatically. + +## If CONNECT is achieved but browsing fails, try activating the following line + Auto DNS = yes +## To make a logfile wvdial.out + wvdial 2>&1 | tee wvdial.out +# # For some Internet providers, the following line is necessary + Stupid Mode = yes +## for other wvdial options, do "man wvdial" or see the documentation in +## /usr/share/doc/wvdial/ +## End wvdial.conf diff --git a/bash/trap/trap.sh b/bash/trap/trap.sh new file mode 100755 index 0000000..7c85f47 --- /dev/null +++ b/bash/trap/trap.sh @@ -0,0 +1,7 @@ +#!/bin/sh + +trap 'echo bye ; exit 0' INT + +while [[ "" == "" ]]; do + echo aa +done diff --git a/bash/xml/xmlstarlet/file.xml b/bash/xml/xmlstarlet/file.xml new file mode 100644 index 0000000..fef5b8c --- /dev/null +++ b/bash/xml/xmlstarlet/file.xml @@ -0,0 +1,7 @@ + + + + + /home/username/ + + diff --git a/cpp/boost/yAx/.ccc.swp b/cpp/boost/yAx/.ccc.swp new file mode 100644 index 0000000000000000000000000000000000000000..848487c09a9c696759f26660d41fadd29b5d90e7 GIT binary patch literal 12288 zcmeI2O>5LZ7{{M_Q>cm_yiT{5EYv2uD=OKv5a>m);AKVeP$t=Fjm=I%GAXsyiWg6Q zg?EOoiwG6EUy28mWJX>?RIv>#>33l*B&4w57{_Dg@?4#SYrw5=X-7=VEb z8Ys;6?fZ+PLBHpe9hN&w;^vLf1)HG^24DaNU;qYS00v+H24G+w4VZL+-tfjRHJiWH z%nSd_%}-1)00S@p126ysFaQHE00S@p126ysb7(-0iSk9FuT1&>|JnEd={2Gc%sb`@ z<1km4%gpDiM4y;b<|A{$95Zj3L*^;7!7MR?`Nh3|GT)l_obY_i959N(fB_hQ0T_S* z7=Qs7fB_hQfw?#Engowboz14mv~Y&}Rm5ZJqRAqucZyhMTN7#im(miO5}vXo#Q7Iy z(Y`lMiXc|&;-Teto2}+%?7Cr67|-kYYaP$?J+E3*dK?d{)5OKrwhT>@MF*-XERUF* zwlY~2`&Mto>54URcPPr|Uimzz8~c`1$L^Fd=Uj{x{k>z~>aX;9&xaIgBPKG^R+p&A zBfTTEoTxmNp%T@tbJx|yL}gLvx_nxh^Ffy*9md6239r7F-Xz#n+>VRY=V`j$l2x{v ZCGU^*S+b*KmaJOFESY literal 0 HcmV?d00001 diff --git a/cpp/boost/yAx/aaa b/cpp/boost/yAx/aaa new file mode 100644 index 0000000..4299a0f --- /dev/null +++ b/cpp/boost/yAx/aaa @@ -0,0 +1,22 @@ +#include +#include +#include +#include +#include +#include + +using namespace boost::numeric::ublas; + +int main() +{ + matrix A(2,2); + A(0,0) = 4; A(0,1) = 3; + A(1,0) = 6; A(1,1) = 3; + std::cout<<"A="< +#include +#include + + +using namespace std; +using namespace boost; +using namespace boost::filesystem; + + +static void Process_Files( const path &Path, bool recurse ) +{ + cout << "Processing folder " << Path.native_file_string() << "\n"; + + directory_iterator end_itr; // default construction yields past-the-end + + for( + directory_iterator itr( Path ); + itr != end_itr; + ++itr + ) + { + if( recurse && is_directory( *itr ) ) + { + // Погружаемся на 1 уровень вниз по дереву каталогов + path Deeper( *itr ); + + Process_Files( Deeper,recurse ); + continue; + } + + + // Файл, путь к которому содержится в filename, можно обрабатывать. + string filename = itr->native_file_string(); + cout << filename << "\n"; + } + + return; +} + +int main( int argc, char* argv[] ) +{ + bool recurse=true; // обходить ли каталоги + Process_Files( current_path(), recurse ); + return 0; +} diff --git a/cpp/static_map/static_map b/cpp/static_map/static_map new file mode 100755 index 0000000000000000000000000000000000000000..40967e5b6fee2e5f3e3cdb6a1c4110ecaaccdff9 GIT binary patch literal 15354 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 literal 0 HcmV?d00001 diff --git a/cpp/static_map/static_map.cpp b/cpp/static_map/static_map.cpp new file mode 100644 index 0000000..c0b4c53 --- /dev/null +++ b/cpp/static_map/static_map.cpp @@ -0,0 +1,25 @@ +#include +#include + + struct pair + { + std::string offs; + std::string scal; + pair(const std::string& o, const std::string& s) + { + offs = o; + scal = s; + } + }; + + +void f() +{ + std::map old_ch_names; +} + +int main() +{ + f(); + return 0; +}