You must have bison and flex installed on your system. I recommend that your environment is Ubuntu since it has the  make program.

Write a calculator program that allows the use of real number constants, variable names consisting of one-to-two letters followed by zero-to-two digits.

The operations allowed are:

• + (add)
• - (subtract)
• - (negate)
• * (multiply)
• / (divide)
• ^ (raise to power)

You can use grouping symbols ( ) to group operations that need to be done before others.

The priority of operations are:

• ^ — highest priority
• *, /
• +, -, – (negate)

There are two kinds of calculator commands: expressions and assignments.

1. If an expression is entered as a command, then the expression is evaluated and its value is printed.
2. If an assignment is entered as a command, the expression is assigned to the variable name, and the value of the variable is
   printed.

Examples of calculator commands are:

Command                      Output
@a = 25;                     25         assignment
@b = 32;                     32         assignment
a+b;                         57         expression
@a = 2*a+5;                  55         assignment
@c = (a + b)*2;             174         assignment
a+b+c+3;                    264         expression
25+x;                       undefined   expression
@d = a/0;                   undefined   assignment
@aa23 = a*2 + b*3;          206         assignment
aa23 + 7.3;                 213.3       expression

Write the lexical analyzer in a file, lexana.l.
Write the bison grammar in a file, grammar.y.
Name the final executable, calculator.

The grammar for the calculator was provided to us by our professor.

lexana.l

%{
/*	Written by: Yancy Vance M. Paredes. */
#include
#include
#include
#include "grammar.tab.h"

#define TABSIZE 1000
#define true 1
#define false 0

char* var_names[TABSIZE];	// where the variable names will be stored
int var_def[TABSIZE];		// flag to determine whether a var is defined
int n_of_names = 0;		    // counter of variables

void reset()
{
	/* this will just reset all the flags to false */
	int j;
	for(j = 0; j < TABSIZE; j++)
		var_def[j] = false;
}

int install(char *txt)
{
	int j; char *s;

    /* if the table of var_names is still empty */
    /* add the first record at 0 and return 0 */
    if(n_of_names == 0) {
        s = strdup(txt);
        var_names[0] = s;
        ++n_of_names;
        return 0;
    }

    /* if the table has contents already, return the index */
    for(j = 0; j < n_of_names; ++j) {
        if(strcmp(txt, var_names[j]) == 0) {
            return j;
        }
    }

    /* if the table is not empty and the var name is not yet listed */
    /* list the new var name and return the index */
    s = strdup(txt);
    var_names[j] = s;
    ++n_of_names;
    return j;
}

%}

ALPHA	[a-z]|[a-z][a-z]
NUM		[0-9]|[0-9][0-9]

%%

[ \n\t]					{ }

[0-9][0-9]*(\.[0-9]+)?	{
	/* convert yytext to a double and return it  */
	yylval.num = atof(yytext);
	return NUMBER;
}

{ALPHA}|{ALPHA}{NUM}	{
	/* install the variable found to the array and return the index */
	yylval.index = install(yytext);
	return VARIABLE;
}

.						{
	return yytext[0];
}

%%

int yywrap(void)
{
    return 1;
}

This is the source code for the lexical analyzer. It is responsible for reading the tokens by matching the input of the user with the different regular expressions.

grammar.y

%{
/*	Written by: Yancy Vance M. Paredes. */
#include
#include
#include
#include

#define TABSIZE 1000
#define true 1
#define false 0

/* the following were defined in lexana.l */
extern char* var_names[TABSIZE];
extern int var_def[TABSIZE];
extern int n_of_names;
extern int install(char *txt);
extern void reset();

/* variables for the grammar file */
int invalid = false;			// just added for error checking
double var_values[TABSIZE];		// array where all the values are stored

int yyerror(const char *p)
{
	fprintf(stderr, "%s\n", p);	// print the error message
	invalid = true;
}

%}

%union {
	/* this will be used for the yylval. */
	/* it is a union since two data types will be used */
	double num;		// the number provided by the user
	int index;		// index of the variable name inside the array
};

%start manycmds
%token  VARIABLE
%token  NUMBER
%type  onecmd
%type  expression
%type  assignment
%type  term
%type  factor
%type  primary

%%

manycmds : onecmd							{ }
|	manycmds onecmd							{ }
;

onecmd : expression ';'						{ if(!invalid) fprintf(stderr, "%lf\n", $1); invalid = 0; }
|	assignment ';'							{ if(!invalid) fprintf(stderr, "%lf\n", $1); invalid = 0; }

expression : term 							{ $$ = $1; }
|	'-' term 								{ $$ = -$2; }
|	expression '+' term						{ $$ = $1 + $3; }
|	expression '-' term						{ $$ = $1 - $3; }
;

term : factor								{ $$ = $1; }
|	term '*' factor							{ $$ = $1 * $3; }
|	term '/' factor							{ if($3 == 0) yyerror("undefined"); else $$ = $1 / $3;  }
;

factor : primary 							{ $$ = $1; }
|	primary '^' factor						{ $$ = pow($1, $3); }
;

primary : NUMBER 							{ $$ = $1; }
|	VARIABLE								{ if(!var_def[$1]) yyerror("undefined"); else $$ = var_values[$1]; }
|	'(' expression ')'						{ $$ = $2; }
;

assignment : '@' VARIABLE '=' expression	{ $$ = var_values[$2] = $4; var_def[$2] = 1; }
;

%%

int main(void)
{
	/* reset all the definition flags first */
	reset();

	yyparse();

	return 0;
}

This is the source code for the grammar of the program. It works along with the lexical analyzer. It retrieves all the tokens from the lexical analyzer.

To compile everything into an executable program, we issue the following commands:

bison -d grammar.y
flex lexana.l
gcc grammar.tab.c lex.yy.c -lm -o calculator

The first command will compile the grammar and generate a header file along with it (because of the -d flag.) The second command will compile the lexical analyzer. The third command will merge the two C codes into one. The -lm flag will look for the math library of C.

The executable file created is named calculator.

sudo dmidecode

If you are not comfortable with working with the terminal, you can just install some GUI tools available.

sudo apt-get install imagemagick

Next, go to the directory where you placed all your images.

mogrify -resize 50% -format jpg *

The following code will resize all the pictures to 50% of their size maintaining their aspect ratio. The file extension of the output would be JPG. Be careful, though, because this will not delete the original files.

For more information, see the official documentation here.

If you want to remove Ubuntu from your system, you could just format the partition where it is installed. However, chances are, the GRUB is still there. To be able to remove it, just follow the following steps I came across the Internet.

Using your Windows XP Installer, go to the Repair (Recovery Console)

fixboot

Press y to confirm.

fixmbr

Press y to confirm.

fixboot

Press y to confirm

exit

And there you have it, GRUB will be removed from your system.

The first thing that you need to install is the alsa server for the sound the work.

sudo apt-get install alsa

After installing, you have to add yourself to the audio group.

sudo adduser yourusername audio

Restart the system for it to take effect.

sudo reboot

Adjust the volume of your system, and unmute the master control.

sudo alsamixer

This is the interface of the alsamixer:

You will know that the master control is muted if there is “MM”. To unmute, just press on the M key of the keyboard.

To install a music player and the LAME, issue the following command:

sudo apt-get install lame moc

To start playing audio files,

mocp

This is the interface of the media player:

Now you have an audio player on your server.

Reference:

http://howto.blbosti.com/2010/03/ubuntu-server-install-alsa-sound-and-moc-music-on-console/

sudo nano /etc/fstab

Just follow the format of an existing entry.

# <file system> <mount point>   <type>  <options>       <dump>  <pass>

To identify the UUID of a device, just issue the command:

sudo blkid

The important thing to take note here is the mount point and the type. The mount point is a directory in your system where you want the partition to be made available.

For example, I set it to /mnt/ext

This means, if I want to access the contents of that partition, all I have to do is go to the /mnt/ext directory, assuming the directory is existing.

The type is basically the file system of the partition.

My setup:
Remote Computer is running on Ubuntu Server
Local Computer is running on Ubuntu Desktop

On your local computer, issue the command:

ssh -X 192.168.1.4

replace with the necessary IP address of your remote computer.

Make sure gparted is installed. If not, install it first.

sudo apt-get install gparted

After the installation, simply run the application:

sudo gparted

A window should appear. It looks something like this:

Then you can now manipulate all the hard disks of your remote computer. Be careful when trying to modify your partition tables.

Do not proceed as a root user. Log in as a user with admin privileges.

Update your software sources first.

sudo apt-get update

Install the transmission package.

sudo apt-get install transmission-daemon

After the installation, create the directory where you want to put all your downloaded files. Let’s just create a Downloads directory inside your home directory.

mkdir ~/Downloads

Since the transmission-daemon runs as the user “debian-transmission”, we have to grant full access to the folder.

sudo chown debian-transmission:debian-transmission ~/Downloads

Add the current user to debian-transmission group.

sudo usermod -a -G debian-transmission <user>

Change the permissions for the directory to allow only owner and group access.

sudo chmod 770 ~/Downloads

Stop the running transmission-daemon first:

sudo service transmission-daemon stop

Edit the configuration file of transmission-daemon:

sudo nano /etc/transmission-daemon/settings.json

The configuration file is easy to understand. Here is my sample configuration:

{
    "alt-speed-down": 50,
    "alt-speed-enabled": false,
    "alt-speed-time-begin": 540,
    "alt-speed-time-day": 127,
    "alt-speed-time-enabled": false,
    "alt-speed-time-end": 1020,
    "alt-speed-up": 50,
    "bind-address-ipv4": "0.0.0.0",
    "bind-address-ipv6": "::",
    "blocklist-enabled": false,
    "blocklist-url": "http://www.example.com/blocklist",
    "cache-size-mb": 4,
    "dht-enabled": true,
    "download-dir": "/home/<user>/Downloads",
    "download-limit": 1000,
    "download-limit-enabled": 0,
    "download-queue-enabled": true,
    "download-queue-size": 5,
    "encryption": 1,
    "idle-seeding-limit": 30,
    "idle-seeding-limit-enabled": false,
    "incomplete-dir": "/home/<user>/Downloads",
    "incomplete-dir-enabled": false,
    "lpd-enabled": false,
    "max-peers-global": 200,
    "message-level": 2,
    "peer-congestion-algorithm": "",
    "peer-limit-global": 240,
    "peer-limit-per-torrent": 60,
    "peer-port": 51413,
    "peer-port-random-high": 65535,
    "peer-port-random-low": 49152,
    "peer-port-random-on-start": false,
    "peer-socket-tos": "default",
    "pex-enabled": true,
    "port-forwarding-enabled": false,
    "preallocation": 1,
    "prefetch-enabled": 1,
    "queue-stalled-enabled": true,
    "queue-stalled-minutes": 30,
    "ratio-limit": 2,
    "ratio-limit-enabled": false,
    "rename-partial-files": true,
    "rpc-authentication-required": true,
    "rpc-bind-address": "0.0.0.0",
    "rpc-enabled": true,
    "rpc-password": "{0b0d1b180f589aed6c3e1ad71ac225880411d2d1hS3pQ8Gj",
    "rpc-port": 9091,
    "rpc-url": "/transmission/",
    "rpc-username": "transmission",
    "rpc-whitelist": "127.0.0.1, 192.168.*.*",
    "rpc-whitelist-enabled": false,
    "scrape-paused-torrents-enabled": true,
    "script-torrent-done-enabled": false,
    "script-torrent-done-filename": "",
    "seed-queue-enabled": false,
    "seed-queue-size": 10,
    "speed-limit-down": 100,
    "speed-limit-down-enabled": false,
    "speed-limit-up": 100,
    "speed-limit-up-enabled": false,
    "start-added-torrents": true,
    "trash-original-torrent-files": false,
    "umask": 18,
    "upload-limit": 100,
    "upload-limit-enabled": 0,
    "upload-slots-per-torrent": 14,
    "utp-enabled": true
}

You have to change the to the username you used to create the directory earlier.

Save the changes and then reload the service:

sudo service transmission-daemon start

Go to the transmission web interface.

http://localhost:9091

Or, just replace localhost with the IP address of the computer in the network.

The default username is: transmission and the password is transmission.

If you want to change the username and password, just edit the setting.json file.

Stop the service first.

sudo service transmission-daemon stop

Find the following lines:

    ...
    "rpc-password": "password",
    ...
    "rpc-username": "yancy",
    ...

For example, I want to change the username to “yancy” and the password to “password”.

Save the file afterwards and start the service.

sudo service transmission-daemon start

Go to the web interface and log in with the new credentials. After logging in, you will notice that the value for the rpc-password inside the settings.json file will be hashed.

...
perl: warning: Setting locale failed.
perl: warning: Please check that your locale settings:
...

To fix it, I issued the following command:

sudo apt-get install --reinstall language-pack-en

This will fix all the locale problems and will re-install the English language pack.

Other possible solutions can be found here.

The first thing to do is to download the latest version from their official site.

wget http://www.webmin.com/download/deb/webmin-current.deb

Afterwards, install the package.

sudo dpkg -i webmin-current.deb

If there are some dependency packages that are not installed, just issue the following command. This installs the needed packages then webmin afterwards.

sudo apt-get install -f

You can now access Webmin afterwards through: https://localhost:10000. Notice it uses the secured http protocol and it is using port 10000.

You can login as root with your root password, or as any user who can use sudo
to run commands as root.