about summary refs log tree commit diff stats
path: root/setup.sh
blob: 7068a1a955be8080e105dd5d65e56750fc9cc257 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
#!/bin/sh -eu
# Simple script to quickly set up a DSCIP install.

# Get directory where script is running from. As we'll need to come back here
# when the setup script is done.
CWD="$(dirname "$0")"

PROJECT_NAME=""
PROJECT_LOCATION=""
PROJECT_URL=""
PROJECT_BRANCH="master"
TEMPLATE_DIR=""

show_license() {
	echo 'Copyright 2022 Charadon

Licensed under the Apache License, Version 2.0 (the "License"); 
you may not use this file except in compliance with the License. 
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software 
distributed under the License is distributed on an "AS IS" BASIS, 
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
See the License for the specific language governing permissions and 
limitations under the License.'
}

help_screen() {
	echo "USAGE: $0: -n [name] -d [/path/to/install/at] -u [https://example.com/example.git] -b [branch_name] -t [/path/to/templates] (-h|-l)"
	echo "========================================================================"
	echo "-n | Name of Project. (Required)"
	echo "-d | Path where you want dscip to install. (Required)"
	echo "-u | URL to Git Repo. (Required)"
	echo "-b | Branch to build. (Default: master)"
	echo "-t | Path to Templates. (Optional)"
	echo "-h | Shows this screen."
	echo "-l | Shows license."
	echo "If no argument is supplied. Program goes into interactive mode."
	return 0
}

check_config() {
	ERROR_MSG="not set. Aborting. See -h for help."
	if [ "$PROJECT_NAME" = "" ];
	then
		echo "-n $ERROR_MSG" && exit 1
	elif [ "$PROJECT_LOCATION" = "" ];
	then
		echo "-d $ERROR_MSG" && exit 1
	elif [ "$PROJECT_URL" = "" ];
	then
		echo "-u $ERROR_MSG" && exit 1
	fi
	return 0
}

install_dscip() {
	echo "Installing dscip..."
	set -x
	if [ -d "/usr/share/charadon/dscip" ]; # See if dscip is packaged/installed on system.
	then
		cp /usr/share/charadon/dscip/* "$PROJECT_LOCATION"
	elif [ -d /usr/local/share/charadon/dscip ];
	then
		cp /usr/local/share/charaodn/dscip/* "$PROJECT_LOCATION"
	else # If not, clone it from upstream.
		git clone "https://opencode.net/charadon/dscip" "$PROJECT_LOCATION"
	fi
	cd "$PROJECT_LOCATION"
	# Modifying config.sh with variables obtained from setup.sh
	sed -i "s}DSCIP_GITREPO=.*}DSCIP_GITREPO=\"$PROJECT_URL\"}g" config.sh
	sed -i "s/DSCIP_NAME=.*/DSCIP_NAME=\"$PROJECT_NAME\"/g" config.sh
	sed -i "s/DSCIP_BRANCH=.*/DSCIP_BRANCH=\"$PROJECT_BRANCH\"/g" config.sh
	# Copy templates.
	if [ ! "$TEMPLATE_DIR" = "" ];
	then
		cp "$TEMPLATE_DIR"/* .
	fi
	# Done. Go back to CWD, and tell user how to activate DSCIP.
	set +x
	printf "\n"
	printf "\e[32mAll done. Be sure to add:\e[0m\n" 
	echo "* * * * * $(dirname "$(readlink -f "$PROJECT_LOCATION")")/dscip"
	printf "\e[32mTo your crontab! Usually by using \`crontab -e\`\e[0m\n\n"
	printf "\e[32mAlternatively, you can run dscip as a daemon by modifying DSCIP_DAEMON in config.sh\n"
	printf "and creating a daemon for your system's init system.\e[0m\n\n"
	cd "$CWD"
}


# Non-interactive Mode
set +u
if [ ! "$1" = "" ];
then
	set -u
	while getopts ':n:d:u:b:t:lh' options;
	do
		case "${options}" in
			n) # Name
				PROJECT_NAME="$OPTARG"
				;;
			d) # Directory to install to.
				PROJECT_LOCATION="$OPTARG"
				;;
			u) # Git Repo URL
				PROJECT_URL="$OPTARG"
				;;
			b) # Git Branch (Optional)
				PROJECT_BRANCH="$OPTARG"
				;;
			t) # Template Directory (Optional)
				TEMPLATE_DIR="$OPTARG"
				;;
			h) # Show Help Screen
				help_screen
				exit 0
				;;
			l) # Show License
				show_license
				exit 0
				;;
			*)
				;;
		esac
	done
	check_config
	install_dscip
	exit 0
fi
set -u

# Interactive Mode
echo "Welcome to DSCIP setup. This script will ask you a few questions."
echo "Notes:"
echo "    1. This script should be running as the user that will be building the software."
echo "    2. Must have a cron daemon with the command: crontab -e, available."
echo "By default, the script runs in interactive mode. But you can use command-line switches"
echo "to use the set up script non-interactively. Use -h for more info."
printf "\n"
echo "If you feel you are ready. Press enter, otherwise press Ctrl-C to cancel."
read -r


ALL_CORRECT="false"

question_name() {
	PROJECT_NAME=""
	while [ "$PROJECT_NAME" = "" ];
	do
		printf "What is the name of the project?: "
		read -r PROJECT_NAME
	done
}

question_location() {
	PROJECT_LOCATION="/home/$USER/$PROJECT_NAME"
	NEW_PROJECT_LOCATION=""
	printf 'Where do you want to install DSCIP? (Default: %s): ' "$PROJECT_LOCATION"
	read -r NEW_PROJECT_LOCATION
	if [ "$NEW_PROJECT_LOCATION" = "" ];
	then
		return 0
	else
		PROJECT_LOCATION="$NEW_PROJECT_LOCATION"
	fi
}

question_giturl() {
	PROJECT_URL=""
	while [ "$PROJECT_URL" = "" ];
	do
		printf "What is the URL of your Git Repo?: "
		read -r PROJECT_URL
	done
}

question_gitbranch() {
	PROJECT_BRANCH="master"
	printf 'What branch from the Git Repo do you want to use? (Default: %s): ' "$PROJECT_BRANCH"
	read -r PROJECT_BRANCH
}

question_templates() {
	TEMPLATE_DIR=""
	printf "If you have a template directory of the pre,post,build,failed.sh scripts.\nEnter it's location here, otherwise press Enter: "
	read -r TEMPLATE_DIR
}

question_allcorrect() {
	echo "Is all this information correct? Press the number to edit specific variables:"
	echo "1. Project Name: $PROJECT_NAME"
	echo "2. DSCIP Location: $PROJECT_LOCATION"
	echo "3. Git URL: $PROJECT_URL"
	echo "4. Git Branch: $PROJECT_BRANCH"
	echo "5. Template Directory: $TEMPLATE_DIR"
	printf "\nIf all information is correct. Press Enter.\nOtherwise, use a number and then press enter to edit: "
}

question_name
printf "\n"
question_location
printf "\n"
question_giturl
printf "\n"
question_gitbranch
printf "\n"
question_templates
printf "\n"

CHOICE=""

while [ "$ALL_CORRECT" = "false" ];
do
	question_allcorrect
	read -r CHOICE
	printf "\n"
	case "$CHOICE" in
		1)
			question_name
			;;
		2)
			question_location
			;;
		3)
			question_giturl
			;;
		4)
			question_gitbranch
			;;
		5)
			question_templates
			;;
		*)
			ALL_CORRECT="true"
			;;
	esac
	printf "\n"
done
check_config
install_dscip
f32b09f311cc'>839dc88d ^
46bb1d31 ^
b6c7f481 ^
5bd6dc8e ^



4557b073 ^
d373c008 ^

839dc88d ^

33fdc60b ^
46bb1d31 ^
b6c7f481 ^
5bd6dc8e ^



4557b073 ^
33fdc60b ^



294a1520 ^
46bb1d31 ^
b6c7f481 ^
5bd6dc8e ^




4557b073 ^
294a1520 ^




a8adfff3 ^

fd91f7f6 ^













4fe73d47 ^
a8adfff3 ^

fd91f7f6 ^


e97b446a ^
fd91f7f6 ^
e97b446a ^
915aaa21 ^



a8adfff3 ^
e97b446a ^
a8adfff3 ^


099f0d5d ^
fd91f7f6 ^
6ecddbaa ^
099f0d5d ^
915aaa21 ^



099f0d5d ^




6ecddbaa ^
fd91f7f6 ^
6ecddbaa ^

915aaa21 ^



6ecddbaa ^




6ecddbaa ^
fd91f7f6 ^
5030d67c ^
dac83357 ^




46bb1d31 ^
dac83357 ^

04a5722e ^
51a20da6 ^
04a5722e ^
dac83357 ^


46bb1d31 ^
dac83357 ^

c086f1be ^
51a20da6 ^
29ec821c ^
fd91f7f6 ^
dac83357 ^

fd91f7f6 ^
dac83357 ^

dbb380b8 ^
839dc88d ^
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
         










                                                                                   



               

                                                

                                            
 
       
 

                      

                                           

                  
        
                                                            
                                                           



                                                       
                   




                                                       
                                                            
                                                           



                                     
                   




                          
                                                            
                                                           



                                      
                   




                                      
                                                            
                                                           



                                                     
                   




                                          
                                                            
                                                           



                                                     
                   




                                          
                                                            
                                                           



                                            
                   




                                        
                                                            
                                                           



                                     
                   




                          
                                                            
                                                          



                                          
                   




                                   
                                                            
                                                          



                                         
                   




                              
                                                              
                                                           




                                                   
                   





                                        
                                                              
                                                           



                          
                   


               
 
         
                                                              
                                                           
                                                                                                            
                               
 

                                            
              
                                                                        
                                                             





                                       
                   

                                   
                     
      


                
                                                                            
                                                               



                                  
                   

                       

 
                 
                                                                              
                                                                



                                   
                   



                        
           
                                                                  
                                                          




                                                                                     
                   




                                                                                     

                                            













                                                                                         
 

                      


                                                                            
           
                                                                                        
                                                        



                             
                             
                  


      
          
                                                                                      
                                       
                                                       



                            




                             
           
                                                                                                      

                                                        



                             




                             
                        
                                              
 




                   
                                          

                          
 
                                            
 


                                                    
                                              

                      
 
                                            
 
                                                                   

           
                                                                    

                      
 
      
#!/bin/sh
# Build and test all included SubX programs:
#   translate them into ELF binaries
#   compare the generated binaries with what's already in git
#   run/test the ELF binaries in emulated mode (unless $NO_EMULATION)
#   run/test the ELF binaries in native mode (if on Linux)
#
# Example usage:
#   test_apps  # compare generated binaries, run them in emulated and native mode
#   test_apps record  # run binaries in emulated and native mode
#   NO_EMULATION=1 test_apps  # compare generated binaries, run them in native mode
#   NO_EMULATION=1 test_apps record  # run binaries just in native mode

set -e
cd `dirname $0`

test $NO_EMULATION  ||  EMULATED=1
test $EMULATED  &&  echo 'testing emulated runs'
test `uname` = 'Linux'  &&  NATIVE=1
test $NATIVE  &&  echo 'testing native runs'

./build

export OS=${OS:-linux}

echo "== translating and running using C++"

# example programs

echo ex1
./subx translate init.$OS examples/ex1.subx  -o examples/ex1
test "$1" = 'record'  ||  git diff --exit-code examples/ex1
test $EMULATED  &&  {
  ./subx run examples/ex1  ||  ret=$?
  test $ret -eq 42  # life, the universe and everything
}
test $NATIVE  &&  {
  examples/ex1  ||  ret=$?
  test $ret -eq 42  # life, the universe and everything
}

echo ex2
./subx translate init.$OS examples/ex2.subx  -o examples/ex2
test "$1" = 'record'  ||  git diff --exit-code examples/ex2
test $EMULATED  &&  {
  ./subx run examples/ex2  ||  ret=$?
  test $ret -eq 2  # 1 + 1
}
test $NATIVE  &&  {
  examples/ex2  ||  ret=$?
  test $ret -eq 2  # 1 + 1
}

echo ex3
./subx translate init.$OS examples/ex3.subx  -o examples/ex3
test "$1" = 'record'  ||  git diff --exit-code examples/ex3
test $EMULATED  &&  {
  ./subx run examples/ex3  ||  ret=$?
  test $ret -eq 55  # 1 + 2 + ... + 10
}
test $NATIVE  &&  {
  examples/ex3  ||  ret=$?
  test $ret -eq 55  # 1 + 2 + ... + 10
}

echo ex4
./subx translate init.$OS examples/ex4.subx  -o examples/ex4
test "$1" = 'record'  ||  git diff --exit-code examples/ex4
test $EMULATED  &&  {
  echo a | ./subx run examples/ex4 >ex4.out  ||  true
  test `cat ex4.out` = 'a'
}
test $NATIVE  &&  {
  echo a | examples/ex4 >ex4.out  ||  true
  test `cat ex4.out` = 'a'
}

echo ex5
./subx translate init.$OS examples/ex5.subx  -o examples/ex5
test "$1" = 'record'  ||  git diff --exit-code examples/ex5
test $EMULATED  &&  {
  echo a | ./subx run examples/ex5 >ex5.out  ||  true
  test `cat ex5.out` = 'a'
}
test $NATIVE  &&  {
  echo a | examples/ex5 >ex5.out  ||  true
  test `cat ex5.out` = 'a'
}

echo ex6
./subx translate init.$OS examples/ex6.subx  -o examples/ex6
test "$1" = 'record'  ||  git diff --exit-code examples/ex6
test $EMULATED  &&  {
  ./subx run examples/ex6 >ex6.out  ||  true
  test "`cat ex6.out`" = 'Hello, world!'
}
test $NATIVE  &&  {
  examples/ex6 >ex6.out  ||  true
  test "`cat ex6.out`" = 'Hello, world!'
}

echo ex7
./subx translate init.$OS examples/ex7.subx  -o examples/ex7
test "$1" = 'record'  ||  git diff --exit-code examples/ex7
test $EMULATED  &&  {
  ./subx run examples/ex7  ||  ret=$?
  test $ret -eq 97  # 'a'
}
test $NATIVE  &&  {
  examples/ex7  ||  ret=$?
  test $ret -eq 97  # 'a'
}

echo ex8
./subx translate init.$OS examples/ex8.subx  -o examples/ex8
test "$1" = 'record'  || git diff --exit-code examples/ex8
test $EMULATED  &&  {
  ./subx run examples/ex8 abcd  ||  ret=$?
  test $ret -eq 4  # length('abcd')
}
test $NATIVE  &&  {
  examples/ex8 abcd  ||  ret=$?
  test $ret -eq 4  # length('abcd')
}

echo ex9
./subx translate init.$OS examples/ex9.subx  -o examples/ex9
test "$1" = 'record'  || git diff --exit-code examples/ex9
test $EMULATED  &&  {
  ./subx run examples/ex9 z x  ||  ret=$?
  test $ret -eq 2  # 'z' - 'x'
}
test $NATIVE  &&  {
  examples/ex9 z x  ||  ret=$?
  test $ret -eq 2  # 'z' - 'x'
}

echo ex10
./subx translate init.$OS examples/ex10.subx  -o examples/ex10
test "$1" = 'record'  || git diff --exit-code examples/ex10
test $EMULATED  &&  {
  ./subx run examples/ex10 abc abc  ||  ret=$?
  test $ret -eq 1  # equal
  ./subx run examples/ex10 abc abcd  # 0; not equal
}
test $NATIVE  &&  {
  examples/ex10 abc abc  ||  ret=$?
  test $ret -eq 1  # equal
  examples/ex10 abc abcd  # 0; not equal
}

echo ex11
./subx translate init.$OS examples/ex11.subx  -o examples/ex11
test "$1" = 'record'  || git diff --exit-code examples/ex11
test $EMULATED  &&  {
  ./subx run examples/ex11
  echo
}
test $NATIVE  &&  {
  examples/ex11
  echo
}

echo ex12
./subx translate init.$OS examples/ex12.subx  -o examples/ex12
test "$1" = 'record'  || git diff --exit-code examples/ex12
test $EMULATED  &&  ./subx run examples/ex12  # final byte of mmap'd address is well-nigh guaranteed to be 0
test $NATIVE  &&  examples/ex12

# Larger apps that use the standard library.

echo factorial
./subx translate init.$OS 0*.subx apps/factorial.subx  -o apps/factorial
test "$1" = 'record'  ||  git diff --exit-code apps/factorial
test $EMULATED  &&  {
  ./subx run apps/factorial  ||  ret=$?
  test $ret -eq 120  # factorial(5)
  ./subx run apps/factorial test
  echo
}
test $NATIVE  &&  {
  apps/factorial  ||  ret=$?
  test $ret -eq 120  # factorial(5)
  apps/factorial test
  echo
}

echo crenshaw2-1
./subx translate init.$OS 0*.subx apps/crenshaw2-1.subx  -o apps/crenshaw2-1
test "$1" = 'record'  ||  git diff --exit-code apps/crenshaw2-1
test $EMULATED  &&  {
  ./subx run apps/crenshaw2-1 test
  echo
}
test $NATIVE  &&  {
  apps/crenshaw2-1 test
  echo
}

echo crenshaw2-1b
./subx translate init.$OS 0*.subx apps/crenshaw2-1b.subx  -o apps/crenshaw2-1b
test "$1" = 'record'  ||  git diff --exit-code apps/crenshaw2-1b
test $EMULATED  &&  {
  ./subx run apps/crenshaw2-1b test
  echo
}
test $NATIVE  &&  {
  apps/crenshaw2-1b test
  echo
}

echo handle
./subx translate init.$OS 0*.subx apps/handle.subx  -o apps/handle
test "$1" = 'record'  ||  git diff --exit-code apps/handle
test $EMULATED  &&  {
  ./subx run apps/handle > handle.out 2>&1  ||  true
  grep -q 'lookup succeeded' handle.out  ||  { echo "missing success test"; exit 1; }
  grep -q 'lookup failed' handle.out  ||  { echo "missing failure test"; exit 1; }
}
test $NATIVE  &&  {
  apps/handle > handle.out 2>&1  ||  true
  grep -q 'lookup succeeded' handle.out  ||  { echo "missing success test"; exit 1; }
  grep -q 'lookup failed' handle.out  ||  { echo "missing failure test"; exit 1; }
}

# Phases of the self-hosted SubX translator.

for phase in hex survey pack assort dquotes tests
do
  echo $phase
  ./subx translate init.$OS 0*.subx apps/subx-params.subx apps/$phase.subx -o apps/$phase
  test "$1" = 'record'  ||  git diff --exit-code apps/hex
  test $EMULATED  &&  {
    ./subx run apps/$phase test
    echo
  }
  test $NATIVE  &&  {
    apps/$phase test
    echo
  }
done

# Higher-level syntax.

# Certain phases of translation run native beyond this point. We're starting
# to go beyond functionality of the C++ bootstrap.

echo sigils
./subx translate init.$OS 0*.subx apps/subx-params.subx apps/sigils.subx  -o apps/sigils
[ "$1" != record ]  &&  git diff --exit-code apps/sigils
test $EMULATED  &&  {
  ./subx run apps/sigils test
  echo
}
test `uname` = 'Linux'  &&  {
  apps/sigils test
  echo
}

echo calls
cat init.$OS 0*.subx apps/subx-params.subx apps/calls.subx  |  apps/sigils  > a.sigils
./subx translate a.sigils -o apps/calls
[ "$1" != record ]  &&  git diff --exit-code apps/calls
test $EMULATED  &&  {
  ./subx run apps/calls test
  echo
}
test `uname` = 'Linux'  &&  {
  apps/calls test
  echo
}

echo braces
cat init.$OS 0*.subx apps/subx-params.subx apps/braces.subx  |  apps/calls  |  apps/sigils  > a.sigils
./subx translate a.sigils -o apps/braces
[ "$1" != record ]  &&  git diff --exit-code apps/braces
test $EMULATED  &&  {
  ./subx run apps/braces test
  echo
}
test `uname` = 'Linux'  &&  {
  apps/braces test
  echo
}

test $NATIVE  ||  exit 0
echo "== translating using SubX (native only)"

# example programs

for n in `seq 1 12`
do
  echo ex$n
  ./ntranslate init.$OS examples/ex$n.subx
  diff examples/ex$n a.elf
done

# Larger apps that use the standard library.

for app in factorial crenshaw2-1 crenshaw2-1b handle
do
  echo $app
  ./ntranslate init.$OS 0*.subx apps/$app.subx
  diff apps/$app a.elf
done

# Phases of the self-hosted SubX translator.

for app in hex survey pack assort dquotes tests sigils calls braces
do
  echo $app
  ./ntranslate init.$OS 0*.subx apps/subx-params.subx apps/$app.subx
  diff apps/$app a.elf
done

exit 0