Data commit
This commit is contained in:
Ingy döt Net
parent
7387c8f97b
commit
cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
3
Task/Take-notes-on-the-command-line/00-META.yaml
Normal file
3
Task/Take-notes-on-the-command-line/00-META.yaml
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
---
|
||||
from: http://rosettacode.org/wiki/Take_notes_on_the_command_line
|
||||
note: Text processing
|
||||
12
Task/Take-notes-on-the-command-line/00-TASK.txt
Normal file
12
Task/Take-notes-on-the-command-line/00-TASK.txt
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
{{selection|Short Circuit|Console Program Basics}}[[Category:Basic language learning]] [[Category:Programming environment operations]]
|
||||
{{omit from|EasyLang}}
|
||||
{{omit from|Lotus 123 Macro Scripting}}
|
||||
{{omit from|Maxima}}
|
||||
{{omit from|Openscad}}
|
||||
{{omit from|ZX Spectrum Basic|Does not support command line parameters}}
|
||||
|
||||
Invoking NOTES without commandline arguments displays the current contents of the local NOTES.TXT if it exists.
|
||||
If NOTES has arguments, the current date and time are appended to the local NOTES.TXT followed by a newline.
|
||||
Then all the arguments, joined with spaces, prepended with a tab, and appended with a trailing newline, are written to NOTES.TXT.
|
||||
If NOTES.TXT doesn't already exist in the current directory then a new NOTES.TXT file should be created.
|
||||
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
:start:
|
||||
I :argv.len == 1
|
||||
print(File(‘notes.txt’).read(), end' ‘’)
|
||||
E
|
||||
V f = File(‘notes.txt’, ‘a’)
|
||||
f.write(Time().format("YYYY-MM-DD hh:mm:ss\n"))
|
||||
f.write("\t"(:argv[1..].join(‘ ’))"\n")
|
||||
|
|
@ -0,0 +1,163 @@
|
|||
bits 16
|
||||
cpu 8086
|
||||
;;; MS-DOS PSP locations
|
||||
cmdlen: equ 80h ; Amount of characters on cmdline
|
||||
cmdtail: equ 82h ; Command line tail
|
||||
;;; MS-DOS system calls
|
||||
puts: equ 9h ; Print string to console
|
||||
date: equ 2Ah ; Get system date
|
||||
time: equ 2Ch ; Get system time
|
||||
creat: equ 3Ch ; Create file
|
||||
open: equ 3Dh ; Open file
|
||||
close: equ 3Eh ; Close file
|
||||
read: equ 3Fh ; Read from file
|
||||
write: equ 40h ; Write to file
|
||||
lseek: equ 42h ; Set current file position
|
||||
exit: equ 4ch ; Exit
|
||||
;;; File modes
|
||||
O_RDONLY: equ 0
|
||||
O_WRONLY: equ 1
|
||||
;;; Error codes (well, we only need the one)
|
||||
ENOTFOUND: equ 2
|
||||
;;; File positions (again we need only the one)
|
||||
FP_END: equ 2
|
||||
;;; File buffer size
|
||||
BUFSZ: equ 4096
|
||||
section .text
|
||||
org 100h
|
||||
cmp byte [cmdlen],0 ; Is the command line empty?
|
||||
je printnotes ; Then, go print current notes
|
||||
;;; Retrieve and format current date and time
|
||||
mov ah,date ; Retrieve date
|
||||
int 21h
|
||||
mov di,datefmt ; Fill in date string
|
||||
xor ah,ah
|
||||
mov al,dh ; Write month
|
||||
mov bl,2 ; Two digits
|
||||
call asciinum
|
||||
add di,3 ; Onwards three positions
|
||||
mov al,dl ; Write day
|
||||
mov bl,2 ; Two digits
|
||||
call asciinum
|
||||
add di,3 ; Onwards three positions
|
||||
mov ax,cx ; Write year
|
||||
mov bl,4 ; Four digits
|
||||
call asciinum
|
||||
mov ah,time ; Get system time
|
||||
int 21h
|
||||
mov di,timefmt+6 ; Fill in time string
|
||||
xor ah,ah
|
||||
mov al,dh ; Write seconds
|
||||
mov bl,2 ; Two digits
|
||||
call asciinum
|
||||
sub di,3 ; Back three positions
|
||||
mov al,cl ; Write minutes
|
||||
mov bl,2 ; Two digits
|
||||
call asciinum
|
||||
cmp ch,12 ; AM or PM?
|
||||
jbe houram ; <=12, AM
|
||||
sub ch,12 ; PM - subtract 12 hours,
|
||||
mov byte [ampm],'P' ; And set the AM/PM to 'P'(M)
|
||||
jmp wrhours
|
||||
houram: and ch,ch ; Hour 0 is 12:XX:XX AM.
|
||||
jnz wrhours
|
||||
mov ch,12
|
||||
wrhours: sub di,3 ; Back three positions
|
||||
mov al,ch ; Write hours
|
||||
mov bl,2 ; Two digits
|
||||
call asciinum
|
||||
;;; Open or create the NOTES.TXT file
|
||||
mov dx,filnam
|
||||
mov ax,open<<8|O_WRONLY
|
||||
int 21h ; Try to open the file
|
||||
jnc writenote ; If successful, go write the note
|
||||
cmp al,ENOTFOUND ; File not found?
|
||||
jne diefile ; Some other error = print error msg
|
||||
mov ah,creat ; No notes file, try to create it
|
||||
xor cx,cx ; Normal file (no attributes set)
|
||||
int 21h
|
||||
jc diefile ; If that fails too, print error msg
|
||||
;;; Write the note to the file
|
||||
writenote: mov bx,ax ; File handle in BX
|
||||
mov ax,lseek<<8|FP_END ; Seek to end of file
|
||||
xor cx,cx ; Offset 0
|
||||
xor dx,dx
|
||||
int 21h
|
||||
jc diefile ; Error if it fails
|
||||
mov dx,datetime ; Write the date/time string first
|
||||
mov cx,dtsize
|
||||
mov ah,write
|
||||
int 21h
|
||||
jc diefile ; Error if it fails
|
||||
mov cx,bx ; Store file handle in CX
|
||||
;;; Terminate note with \r\n
|
||||
xor bx,bx ; BX = length of command line
|
||||
mov bl,[cmdlen] ; Find 2 bytes past cmd input
|
||||
add bx,cmdlen+1 ; Note: this might overwrite the first
|
||||
mov word [bx],0A0Dh ; instruction, but we don't need it
|
||||
sub bx,cmdtail-2 ; Get length (add 2 for the 0D0A)
|
||||
xchg bx,cx ; File handle in BX, length in CX
|
||||
mov dx,cmdtail ; Write what's on the command line
|
||||
mov ah,write
|
||||
int 21h
|
||||
jc diefile ; Error if it fails.
|
||||
jmp closeexit ; Close file and exit if it succeeds.
|
||||
;;; Print the contents of the NOTES.TXT file
|
||||
printnotes: mov dx,filnam ; Open file for reading
|
||||
mov ax,open<<8|O_RDONLY
|
||||
int 21h
|
||||
jnc readnotes ; Carry flag set = error.
|
||||
cmp al,ENOTFOUND ; File not found?
|
||||
jne diefile ; Some other error = print error msg
|
||||
jmp exitok ; Not found = no notes = just exit
|
||||
readnotes: mov di,ax ; Keep the file handle in DI.
|
||||
.loop mov bx,di ; Get file handle for file
|
||||
mov cx,BUFSZ ; Read as many bytes as will fit in the
|
||||
mov ah,read ; buffer
|
||||
int 21h
|
||||
jc diefile ; Carry flag set = error
|
||||
and ax,ax ; If 0 bytes read, we're done.
|
||||
jz .done
|
||||
xor bx,bx ; File handle 0 = standard output
|
||||
mov cx,ax ; Write as many bytes as we read
|
||||
mov ah,write
|
||||
int 21h
|
||||
jc diefile
|
||||
jmp .loop ; Go get more bytes if there are any
|
||||
.done mov bx,di ; Done: close the file
|
||||
closeexit: mov ah,close
|
||||
int 21h
|
||||
exitok: mov ax,exit<<8|0 ; Exit with errorlevel 0 (success)
|
||||
int 21h
|
||||
;;; Print 'File error' and exit.
|
||||
diefile: mov dx,fileerror
|
||||
;;; Print error message in DX and exit
|
||||
die: mov ah,puts ; Print error message
|
||||
int 21h
|
||||
mov ax,exit<<8|2 ; Exit with errorlevel 2.
|
||||
int 21h
|
||||
;;; Subroutine: write AX as BL-digit ASCII number at [DI]
|
||||
asciinum: push dx ; Store DX and CX
|
||||
push cx
|
||||
mov cx,10 ; CX = divisor
|
||||
xor bh,bh ; We never need >255.
|
||||
.loop: xor dx,dx ; Set high word of division to 0.
|
||||
div cx ; AX /= CX; DX = AX % CX
|
||||
add dl,'0' ; Make digit ASCII
|
||||
dec bl ; Move forward one digit
|
||||
mov [di+bx],dl ; Store digit
|
||||
jnz .loop ; Are we there yet?
|
||||
pop cx ; Restore DX and CX
|
||||
pop dx
|
||||
ret
|
||||
section .data
|
||||
datetime: equ $ ; Start of date/time string.
|
||||
datefmt: db '**/**/**** ' ; Date placeholder,
|
||||
timefmt: db '**:**:** ' ; Time placeholder,
|
||||
ampm: db 'AM' ; AM/PM placeholder.
|
||||
db 13,10,9 ; \r\n\t
|
||||
dtsize: equ $-datetime ; Size of date/time string.
|
||||
fileerror: db 'File error.$' ; Printed on error
|
||||
filnam: db 'NOTES.TXT',0 ; File name to use
|
||||
section .bss
|
||||
filebuf: resb BUFSZ ; 4K file buffer
|
||||
|
|
@ -0,0 +1,289 @@
|
|||
/* ARM assembly AARCH64 Raspberry PI 3B */
|
||||
/* program notes64.s */
|
||||
|
||||
/************************************/
|
||||
/* Constantes */
|
||||
/************************************/
|
||||
.include "../includeConstantesARM64.inc"
|
||||
.equ BUFFERSIZE, 10000
|
||||
.equ O_APPEND, 0x400
|
||||
.equ GETTIME, 0xa9 // call system linux gettimeofday
|
||||
|
||||
/*******************************************/
|
||||
/* Structures */
|
||||
/********************************************/
|
||||
/* example structure time */
|
||||
.struct 0
|
||||
timeval_sec: //
|
||||
.struct timeval_sec + 8
|
||||
timeval_usec: //
|
||||
.struct timeval_usec + 8
|
||||
timeval_end:
|
||||
.struct 0
|
||||
timezone_min: //
|
||||
.struct timezone_min + 8
|
||||
timezone_dsttime: //
|
||||
.struct timezone_dsttime + 8
|
||||
timezone_end:
|
||||
/*********************************/
|
||||
/* Initialized data */
|
||||
/*********************************/
|
||||
.data
|
||||
szCarriageReturn: .asciz "\n"
|
||||
szSpace: .asciz " "
|
||||
szLibNoFile: .asciz "no file notes.txt in this directory\n"
|
||||
szFileName: .asciz "notes.txt"
|
||||
szMessAnoRead: .asciz "Error read file \n"
|
||||
szMessAnoTime: .asciz "Error call time \n"
|
||||
szMessAnoWrite: .asciz "Error file write \n"
|
||||
szMessDate: .asciz " @/@/@ @:@:@ \n" // message time
|
||||
.align 8
|
||||
tbDayMonthYear: .quad 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335
|
||||
.quad 366, 397, 425, 456, 486, 517, 547, 578, 609, 639, 670, 700
|
||||
.quad 731, 762, 790, 821, 851, 882, 912, 943, 974,1004,1035,1065
|
||||
.quad 1096,1127,1155,1186,1216,1247,1277,1308,1339,1369,1400,1430
|
||||
/*********************************/
|
||||
/* UnInitialized data */
|
||||
/*********************************/
|
||||
.bss
|
||||
sZoneConv: .skip 24
|
||||
stTVal: .skip timeval_end
|
||||
stTZone: .skip timezone_end
|
||||
sBuffer: .skip BUFFERSIZE
|
||||
/*********************************/
|
||||
/* code section */
|
||||
/*********************************/
|
||||
.text
|
||||
.global main
|
||||
main: // entry of program
|
||||
mov fp,sp // stack address
|
||||
ldr x20,[fp] // load number of parameters command line
|
||||
cmp x20,#1 // >1 insertion text
|
||||
bgt 10f
|
||||
mov x0,AT_FDCWD
|
||||
ldr x1,qAdrszFileName // file name
|
||||
mov x2,#O_RDONLY // flags
|
||||
mov x3,#0 // mode in octal
|
||||
mov x8,#OPEN // open file, create if not exist
|
||||
svc 0
|
||||
cmp x0,#0 // error open
|
||||
ble 99f // file no exists ?
|
||||
mov x19,x0 // save FD and if file exist display text
|
||||
ldr x1,qAdrsBuffer // buffer address
|
||||
ldr x2,#iBufferSize // buffersize
|
||||
mov x8,READ
|
||||
svc 0
|
||||
cmp x0,#0 // error read ?
|
||||
blt 98f
|
||||
ldr x0,qAdrsBuffer // buffer address
|
||||
bl affichageMess // and display
|
||||
b 50f
|
||||
10: // multiple parameters in command line
|
||||
mov x0,AT_FDCWD
|
||||
ldr x1,qAdrszFileName // file name
|
||||
ldr x2,iFlag // flags
|
||||
mov x3,#0644 // mode in octal
|
||||
mov x8,#OPEN // open file, create if not exist
|
||||
svc 0
|
||||
cmp x0,#0 // error open
|
||||
ble 96f
|
||||
mov x19,x0 // save FD
|
||||
ldr x0,qAdrstTVal
|
||||
ldr x1,qAdrstTZone
|
||||
mov x8,#GETTIME // call system function time
|
||||
svc 0
|
||||
cmp x0,#-1 // error ?
|
||||
beq 97f
|
||||
ldr x1,qAdrstTVal
|
||||
ldr x0,[x1,timeval_sec] // timestamp in second
|
||||
bl formatTime // format date and hour
|
||||
mov x1,x0
|
||||
mov x2,#0
|
||||
11: // compute length of time message
|
||||
ldrb w3,[x1,x2]
|
||||
cmp w3,#0
|
||||
beq 12f
|
||||
add x2,x2,#1
|
||||
b 11b
|
||||
12:
|
||||
mov x0,x19 // write time message
|
||||
mov x8,#WRITE
|
||||
svc 0
|
||||
cmp x0,#0 // error ?
|
||||
ble 96f
|
||||
mov x5,#2 // start parameters command line
|
||||
13:
|
||||
mov x0,x19 // file FD
|
||||
ldr x1,[fp,x5,lsl #3] // load parameter address
|
||||
mov x2,#0
|
||||
14: // compute parameter length
|
||||
ldrb w3,[x1,x2]
|
||||
cmp w3,#0
|
||||
beq 15f
|
||||
add x2,x2,#1
|
||||
b 14b
|
||||
15: // write parameter
|
||||
mov x8,#WRITE
|
||||
svc 0
|
||||
cmp x0,#0 // error ?
|
||||
ble 96f
|
||||
mov x0,x19 // file FD
|
||||
ldr x1,iadrszSpace // write a space betwin parameters
|
||||
mov x2,#1
|
||||
mov x8,#WRITE
|
||||
svc 0
|
||||
add x5,x5,#1 // increment indixe
|
||||
cmp x5,x20 // parameters maxi ?
|
||||
ble 13b // no -> loop
|
||||
mov x0,x19
|
||||
ldr x1,qAdrszCarriageReturn // write line end
|
||||
mov x2,#1
|
||||
mov x7,#WRITE
|
||||
svc 0
|
||||
|
||||
50: // close the file
|
||||
mov x0,x19
|
||||
mov x8,CLOSE
|
||||
svc 0
|
||||
b 100f
|
||||
|
||||
96: // error write
|
||||
ldr x0,qAdrszMessAnoWrite
|
||||
bl affichageMess
|
||||
b 100f
|
||||
97: // error function time
|
||||
ldr x0,qAdrszMessAnoTime
|
||||
bl affichageMess
|
||||
b 100f
|
||||
98: // error read
|
||||
ldr x0,qAdrszMessAnoRead
|
||||
bl affichageMess
|
||||
b 100f
|
||||
|
||||
99: // display message no file in this directory
|
||||
ldr x0,qAdrszLibNoFile
|
||||
bl affichageMess
|
||||
100: // standard end of the program
|
||||
mov x0, #0 // return code
|
||||
mov x8,EXIT
|
||||
svc #0 // perform the system call
|
||||
|
||||
qAdrszCarriageReturn: .quad szCarriageReturn
|
||||
qAdrsZoneConv: .quad sZoneConv
|
||||
qAdrszFileName: .quad szFileName
|
||||
qAdrszLibNoFile: .quad szLibNoFile
|
||||
qAdrsBuffer: .quad sBuffer
|
||||
iBufferSize: .quad BUFFERSIZE
|
||||
qAdrszMessAnoRead: .quad szMessAnoRead
|
||||
qAdrszMessAnoTime: .quad szMessAnoTime
|
||||
qAdrszMessAnoWrite: .quad szMessAnoWrite
|
||||
iFlag: .quad O_RDWR|O_APPEND|O_CREAT
|
||||
qAdrstTVal: .quad stTVal
|
||||
qAdrstTZone: .quad stTZone
|
||||
iadrszSpace: .quad szSpace
|
||||
/***************************************************/
|
||||
/* formatting time area */
|
||||
/***************************************************/
|
||||
// x0 contains time area
|
||||
// x0 return address result string
|
||||
formatTime:
|
||||
stp x2,lr,[sp,-16]! // save registers
|
||||
ldr x2,qSecJan2020
|
||||
sub x3,x0,x2 // total secondes to 01/01/2020
|
||||
mov x4,60
|
||||
udiv x5,x3,x4
|
||||
msub x6,x5,x4,x3 // compute secondes
|
||||
udiv x3,x5,x4
|
||||
msub x7,x3,x4,x5 // compute minutes
|
||||
mov x4,24
|
||||
udiv x5,x3,x4
|
||||
msub x8,x5,x4,x3 // compute hours
|
||||
mov x4,(365 * 4 + 1)
|
||||
udiv x9,x5,x4
|
||||
lsl x9,x9,2 // multiply by 4 = year1
|
||||
udiv x12,x5,x4
|
||||
msub x10,x12,x4,x5
|
||||
ldr x11,qAdrtbDayMonthYear
|
||||
mov x12,3
|
||||
mov x13,12
|
||||
1:
|
||||
mul x14,x13,x12
|
||||
ldr x15,[x11,x14,lsl 3] // load days by year
|
||||
cmp x10,x15
|
||||
bge 2f
|
||||
sub x12,x12,1
|
||||
cmp x12,0
|
||||
cbnz x12,1b
|
||||
2: // x12 = year2
|
||||
mov x16,11
|
||||
mul x15,x13,x12
|
||||
lsl x15,x15,3 // * par 8
|
||||
add x14,x15,x11
|
||||
3:
|
||||
ldr x15,[x14,x16,lsl 3] // load days by month
|
||||
cmp x10,x15
|
||||
bge 4f
|
||||
sub x16,x16,1
|
||||
cmp x16,0
|
||||
cbnz x16,3b
|
||||
4: // x16 = month - 1
|
||||
mul x15,x13,x12
|
||||
add x15,x15,x16
|
||||
ldr x1,qAdrtbDayMonthYear
|
||||
ldr x3,[x1,x15,lsl 3]
|
||||
sub x0,x10,x3
|
||||
add x0,x0,1 // final compute day
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl conversion10
|
||||
ldr x0,qAdrszMessDate
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl strInsertAtCharInc // insert result at first @ character
|
||||
mov x2,x0
|
||||
add x0,x16,1 // final compute month
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl conversion10
|
||||
mov x0,x2
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl strInsertAtCharInc // insert result at next @ character
|
||||
mov x2,x0
|
||||
add x0,x9,2020
|
||||
add x0,x0,x12 // final compute year = 2020 + year1 + year2
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl conversion10
|
||||
mov x0,x2
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl strInsertAtCharInc // insert result at next @ character
|
||||
mov x2,x0
|
||||
mov x0,x8 // hours
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl conversion10
|
||||
mov x0,x2
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl strInsertAtCharInc // insert result at next @ character
|
||||
mov x2,x0
|
||||
mov x0,x7 // minutes
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl conversion10
|
||||
mov x0,x2
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl strInsertAtCharInc // insert result at next @ character
|
||||
mov x2,x0
|
||||
mov x0,x6 // secondes
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl conversion10
|
||||
mov x4,#0 // store zero final
|
||||
strb w4,[x1,x0]
|
||||
mov x0,x2
|
||||
ldr x1,qAdrsZoneConv
|
||||
bl strInsertAtCharInc // insert result at next // character
|
||||
100:
|
||||
ldp x2,lr,[sp],16 // restaur registers
|
||||
ret
|
||||
qAdrszMessDate: .quad szMessDate
|
||||
qSecJan2020: .quad 1577836800
|
||||
qAdrtbDayMonthYear: .quad tbDayMonthYear
|
||||
|
||||
/***************************************************/
|
||||
/* ROUTINES INCLUDE */
|
||||
/***************************************************/
|
||||
.include "../includeARM64.inc"
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#!/usr/local/bin/apl -s --
|
||||
|
||||
∇r←ch Join ls ⍝ Join list of strings with character
|
||||
r←1↓∊ch,¨ls
|
||||
∇
|
||||
|
||||
∇d←Date ⍝ Get system date as formatted string
|
||||
d←'/'Join ⍕¨1⌽3↑⎕TS
|
||||
∇
|
||||
|
||||
∇t←Time;t24 ⍝ Get system time as formatted string
|
||||
t←t24←3↑3↓⎕TS ⍝ Get system time
|
||||
t[1]←t[1]-12×t24[1]≥12 ⍝ If PM (hour≥12), subtract 12 from hour
|
||||
t[1]←t[1]+12×t[1]=0 ⍝ Hour 0 is hour 12 (AM)
|
||||
t←¯2↑¨'0',¨⍕¨t ⍝ Convert numbers to 2-digit strings
|
||||
t←(':'Join t),(1+t24[1]≥12)⊃' AM' ' PM' ⍝ Add AM/PM and ':' separator
|
||||
∇
|
||||
|
||||
∇Read;f
|
||||
→(¯2≡f←⎕FIO[49]'notes.txt')/0 ⍝ Read file, stop if not found
|
||||
⎕←⊃f ⍝ Output file line by line
|
||||
∇
|
||||
|
||||
∇Write note;f;_
|
||||
note←' 'Join note ⍝ flatten input and separate with spaces
|
||||
note←Date,' ',Time,(⎕UCS 10 9),note,⎕UCS 10 ⍝ note format
|
||||
f←'a'⎕FIO[3]'notes.txt' ⍝ append to file
|
||||
_←(⎕UCS note)⎕FIO[7]f ⍝ write note to end of file
|
||||
_←⎕FIO[4]f ⍝ close the file
|
||||
∇
|
||||
|
||||
∇Notes;note
|
||||
⍎∊('Read' 'Write note')[1+0≠⍴note←4↓⎕ARG]
|
||||
∇
|
||||
|
||||
Notes
|
||||
)OFF
|
||||
|
|
@ -0,0 +1,319 @@
|
|||
/* ARM assembly Raspberry PI or android 32 bits */
|
||||
/* program notes.s */
|
||||
|
||||
/* REMARK 1 : this program use routines in a include file
|
||||
see task Include a file language arm assembly
|
||||
for the routine affichageMess conversion10
|
||||
see at end of this program the instruction include */
|
||||
/* for constantes see task include a file in arm assembly */
|
||||
/************************************/
|
||||
/* Constantes */
|
||||
/************************************/
|
||||
.include "../constantes.inc"
|
||||
.equ BUFFERSIZE, 10000
|
||||
.equ READ, 3 @ system call
|
||||
.equ WRITE, 4 @ Linux syscall
|
||||
.equ OPEN, 5 @ system call
|
||||
.equ CLOSE, 6 @ system call
|
||||
.equ O_RDONLY, 0
|
||||
.equ O_RDWR, 0x0002 @ open for reading and writing
|
||||
.equ O_APPEND, 0x400
|
||||
.equ O_CREAT, 0x40
|
||||
.equ GETTIME, 0x4e @ call system linux gettimeofday
|
||||
|
||||
|
||||
/*******************************************/
|
||||
/* Structures */
|
||||
/********************************************/
|
||||
/* example structure time */
|
||||
.struct 0
|
||||
timeval_sec: @
|
||||
.struct timeval_sec + 4
|
||||
timeval_usec: @
|
||||
.struct timeval_usec + 4
|
||||
timeval_end:
|
||||
.struct 0
|
||||
timezone_min: @
|
||||
.struct timezone_min + 4
|
||||
timezone_dsttime: @
|
||||
.struct timezone_dsttime + 4
|
||||
timezone_end:
|
||||
/*********************************/
|
||||
/* Initialized data */
|
||||
/*********************************/
|
||||
.data
|
||||
szCarriageReturn: .asciz "\n"
|
||||
szSpace: .asciz " "
|
||||
szLibNoFile: .asciz "no file notes.txt in this directory\n"
|
||||
szFileName: .asciz "notes.txt"
|
||||
szMessAnoRead: .asciz "Error read file \n"
|
||||
szMessAnoTime: .asciz "Error call time \n"
|
||||
szMessAnoWrite: .asciz "Error file write \n"
|
||||
szMessDate: .asciz " @/@/@ @:@:@ \n" @ message time
|
||||
.align 4
|
||||
tbDayMonthYear: .int 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335
|
||||
.int 366, 397, 425, 456, 486, 517, 547, 578, 609, 639, 670, 700
|
||||
.int 731, 762, 790, 821, 851, 882, 912, 943, 974,1004,1035,1065
|
||||
.int 1096,1127,1155,1186,1216,1247,1277,1308,1339,1369,1400,1430
|
||||
/*********************************/
|
||||
/* UnInitialized data */
|
||||
/*********************************/
|
||||
.bss
|
||||
sZoneConv: .skip 24
|
||||
stTVal: .skip timeval_end
|
||||
stTZone: .skip timezone_end
|
||||
sBuffer: .skip BUFFERSIZE
|
||||
/*********************************/
|
||||
/* code section */
|
||||
/*********************************/
|
||||
.text
|
||||
.global main
|
||||
main: @ entry of program
|
||||
mov fp,sp @ stack address
|
||||
ldr r4,[fp] @ load number of parameters command line
|
||||
cmp r4,#1 @ >1 insertion text
|
||||
bgt 10f
|
||||
ldr r0,iAdrszFileName @ file name
|
||||
mov r1,#O_RDONLY @ flags
|
||||
mov r2,#0 @ mode in octal
|
||||
mov r7,#OPEN @ oen file, create if not exist
|
||||
svc 0
|
||||
cmp r0,#0 @ error open
|
||||
ble 99f @ file no exists ?
|
||||
mov r8,r0 @ save FD @ if exist display text
|
||||
ldr r1,iAdrsBuffer @ buffer address
|
||||
ldr r2,#iBufferSize @ buffersize
|
||||
mov r7, #READ @ read file
|
||||
svc 0
|
||||
cmp r0,#0 @ error read ?
|
||||
blt 98f
|
||||
ldr r0,iAdrsBuffer @ buffer address
|
||||
bl affichageMess @ and display
|
||||
b 50f
|
||||
10: @ multiple parameters in command line
|
||||
ldr r0,iAdrszFileName @ file name
|
||||
ldr r1,iFlag @ flags
|
||||
mov r2,#0644 @ mode in octal
|
||||
mov r7,#OPEN @ open file, create if not exist
|
||||
svc 0
|
||||
cmp r0,#0 @ error open
|
||||
ble 96f
|
||||
mov r8,r0 @ save FD
|
||||
ldr r0,iAdrstTVal
|
||||
ldr r1,iAdrstTZone
|
||||
mov r7,#GETTIME @ call system function time
|
||||
svc 0
|
||||
cmp r0,#-1 @ error ?
|
||||
beq 97f
|
||||
ldr r0,iAdrstTVal
|
||||
bl formatTime @ format date and hour
|
||||
mov r1,r0
|
||||
mov r2,#0
|
||||
11: @ compute length of time message
|
||||
ldrb r3,[r1,r2]
|
||||
cmp r3,#0
|
||||
beq 12f
|
||||
add r2,#1
|
||||
b 11b
|
||||
12:
|
||||
mov r0,r8 @ write time message
|
||||
mov r7,#WRITE
|
||||
svc 0
|
||||
cmp r0,#0 @ error ?
|
||||
ble 96f
|
||||
mov r5,#2 @ start parameters command line
|
||||
13:
|
||||
mov r0,r8 @ file FD
|
||||
ldr r1,[fp,r5,lsl #2] @ load parameter address
|
||||
mov r2,#0
|
||||
14: @ compute parameter length
|
||||
ldrb r3,[r1,r2]
|
||||
cmp r3,#0
|
||||
beq 15f
|
||||
add r2,#1
|
||||
b 14b
|
||||
15: @ write parameter
|
||||
mov r7,#WRITE
|
||||
svc 0
|
||||
cmp r0,#0 @ error ?
|
||||
ble 96f
|
||||
mov r0,r8 @ file FD
|
||||
ldr r1,iadrszSpace @ write a space betwin parameters
|
||||
mov r2,#1
|
||||
mov r7,#WRITE
|
||||
svc 0
|
||||
add r5,#1 @ increment indixe
|
||||
cmp r5,r4 @ parameters maxi ?
|
||||
ble 13b @ no -> loop
|
||||
mov r0,r8
|
||||
ldr r1,iAdrszCarriageReturn @ write line end
|
||||
mov r2,#1
|
||||
mov r7,#WRITE
|
||||
svc 0
|
||||
|
||||
50: @ close the file
|
||||
mov r0,r8
|
||||
mov r7, #CLOSE
|
||||
svc 0
|
||||
b 100f
|
||||
|
||||
96: @ error write
|
||||
ldr r0,iAdrszMessAnoWrite
|
||||
bl affichageMess
|
||||
b 100f
|
||||
97: @ error function time
|
||||
ldr r0,iAdrszMessAnoTime
|
||||
bl affichageMess
|
||||
b 100f
|
||||
98: @ error read
|
||||
ldr r0,iAdrszMessAnoRead
|
||||
bl affichageMess
|
||||
b 100f
|
||||
|
||||
99: @ display message no file in this directory
|
||||
ldr r0,iAdrszLibNoFile
|
||||
bl affichageMess
|
||||
100: @ standard end of the program
|
||||
mov r0, #0 @ return code
|
||||
mov r7, #EXIT @ request to exit program
|
||||
svc #0 @ perform the system call
|
||||
|
||||
iAdrszCarriageReturn: .int szCarriageReturn
|
||||
iAdrsZoneConv: .int sZoneConv
|
||||
iAdrszFileName: .int szFileName
|
||||
iAdrszLibNoFile: .int szLibNoFile
|
||||
iAdrsBuffer: .int sBuffer
|
||||
iBufferSize: .int BUFFERSIZE
|
||||
iAdrszMessAnoRead: .int szMessAnoRead
|
||||
iAdrszMessAnoTime: .int szMessAnoTime
|
||||
iAdrszMessAnoWrite: .int szMessAnoWrite
|
||||
iFlag: .int O_RDWR|O_APPEND|O_CREAT
|
||||
iAdrstTVal: .int stTVal
|
||||
iAdrstTZone: .int stTZone
|
||||
iadrszSpace: .int szSpace
|
||||
/***************************************************/
|
||||
/* formatting time area */
|
||||
/***************************************************/
|
||||
// r0 contains time area
|
||||
// r0 return address result string
|
||||
formatTime:
|
||||
push {r2-r12,lr} @ save registers
|
||||
ldr r1,[r0,#timeval_sec] @ timestemp in second
|
||||
ldr r2,iSecJan2020
|
||||
sub r0,r1,r2 @ total secondes to 01/01/2020
|
||||
mov r1,#60
|
||||
bl division
|
||||
mov r0,r2
|
||||
mov r6,r3 @ compute secondes
|
||||
mov r1,#60
|
||||
bl division
|
||||
mov r7,r3 @ compute minutes
|
||||
mov r0,r2
|
||||
mov r1,#24
|
||||
bl division
|
||||
mov r8,r3 @ compute hours
|
||||
mov r0,r2
|
||||
mov r11,r0
|
||||
mov r1,#(365 * 4 + 1)
|
||||
bl division
|
||||
lsl r9,r2,#2 @ multiply by 4 = year1
|
||||
mov r1,#(365 * 4 + 1)
|
||||
mov r0,r11
|
||||
bl division
|
||||
mov r10,r3
|
||||
ldr r1,iAdrtbDayMonthYear
|
||||
mov r2,#3
|
||||
mov r3,#12
|
||||
1:
|
||||
mul r11,r3,r2
|
||||
ldr r12,[r1,r11,lsl #2] @ load days by year
|
||||
cmp r10,r12
|
||||
bge 2f
|
||||
sub r2,r2,#1
|
||||
cmp r2,#0
|
||||
bne 1b
|
||||
2: @ r2 = year2
|
||||
mov r5,#11
|
||||
mul r4,r3,r2
|
||||
lsl r4,#2
|
||||
add r4,r1
|
||||
3:
|
||||
ldr r12,[r4,r5,lsl #2] @ load days by month
|
||||
cmp r10,r12
|
||||
bge 4f
|
||||
subs r5,r5,#1
|
||||
bne 3b
|
||||
4: @ r5 = month - 1
|
||||
mul r11,r3,r2
|
||||
add r11,r5
|
||||
ldr r1,iAdrtbDayMonthYear
|
||||
ldr r3,[r1,r11,lsl #2]
|
||||
sub r0,r10,r3
|
||||
|
||||
add r0,r0,#1 @ final compute day
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl conversion10 @ this function do not zero final
|
||||
mov r4,#0 @ store zero final
|
||||
strb r4,[r1,r0]
|
||||
ldr r0,iAdrszMessDate
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl strInsertAtCharInc @ insert result at first @ character
|
||||
mov r3,r0
|
||||
add r0,r5,#1 @ final compute month
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl conversion10
|
||||
mov r4,#0 @ store zero final
|
||||
strb r4,[r1,r0]
|
||||
mov r0,r3
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl strInsertAtCharInc @ insert result at next @ character
|
||||
mov r3,r0
|
||||
ldr r11,iYearStart
|
||||
add r0,r9,r11
|
||||
add r0,r0,r2 @ final compute year = 2020 + year1 + year2
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl conversion10
|
||||
mov r4,#0 @ store zero final
|
||||
strb r4,[r1,r0]
|
||||
mov r0,r3
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl strInsertAtCharInc @ insert result at next @ character
|
||||
mov r3,r0
|
||||
mov r0,r8 @ hours
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl conversion10
|
||||
mov r4,#0 @ store zero final
|
||||
strb r4,[r1,r0]
|
||||
mov r0,r3
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl strInsertAtCharInc @ insert result at next @ character
|
||||
mov r3,r0
|
||||
mov r0,r7 @ minutes
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl conversion10
|
||||
mov r4,#0 @ store zero final
|
||||
strb r4,[r1,r0]
|
||||
mov r0,r3
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl strInsertAtCharInc @ insert result at next @ character
|
||||
mov r3,r0
|
||||
mov r0,r6 @ secondes
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl conversion10
|
||||
mov r4,#0 @ store zero final
|
||||
strb r4,[r1,r0]
|
||||
mov r0,r3
|
||||
ldr r1,iAdrsZoneConv
|
||||
bl strInsertAtCharInc @ insert result at next @ character
|
||||
|
||||
100:
|
||||
pop {r2-r12,pc} @ restaur registers
|
||||
iAdrszMessDate: .int szMessDate
|
||||
iSecJan2020: .int 1577836800
|
||||
iAdrtbDayMonthYear: .int tbDayMonthYear
|
||||
iYearStart: .int 2020
|
||||
|
||||
/***************************************************/
|
||||
/* ROUTINES INCLUDE */
|
||||
/***************************************************/
|
||||
.include "../affichage.inc"
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
# syntax: GAWK -f TAKE_NOTES.AWK [notes ... ]
|
||||
# examples:
|
||||
# GAWK -f TAKE_NOTES.AWK Hello world
|
||||
# GAWK -f TAKE_NOTES.AWK A "B C" D
|
||||
# GAWK -f TAKE_NOTES.AWK
|
||||
BEGIN {
|
||||
log_name = "NOTES.TXT"
|
||||
(ARGC == 1) ? show_log() : update_log()
|
||||
exit(0)
|
||||
}
|
||||
function show_log( rec) {
|
||||
while (getline rec <log_name > 0) {
|
||||
printf("%s\n",rec)
|
||||
}
|
||||
}
|
||||
function update_log( i,q) {
|
||||
print(strftime("%Y-%m-%d %H:%M:%S")) >>log_name
|
||||
printf("\t") >>log_name
|
||||
for (i=1; i<=ARGC-1; i++) {
|
||||
q = (ARGV[i] ~ / /) ? "\"" : ""
|
||||
printf("%s%s%s ",q,ARGV[i],q) >>log_name
|
||||
}
|
||||
printf("\n") >>log_name
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
with Ada.Calendar.Formatting;
|
||||
with Ada.Characters.Latin_1;
|
||||
with Ada.Command_Line;
|
||||
with Ada.IO_Exceptions;
|
||||
with Ada.Text_IO;
|
||||
procedure Notes is
|
||||
Notes_Filename : constant String := "notes.txt";
|
||||
Notes_File : Ada.Text_IO.File_Type;
|
||||
Argument_Count : Natural := Ada.Command_Line.Argument_Count;
|
||||
begin
|
||||
if Argument_Count = 0 then
|
||||
begin
|
||||
Ada.Text_IO.Open
|
||||
(File => Notes_File,
|
||||
Mode => Ada.Text_IO.In_File,
|
||||
Name => Notes_Filename);
|
||||
while not Ada.Text_IO.End_Of_File (File => Notes_File) loop
|
||||
Ada.Text_IO.Put_Line (Ada.Text_IO.Get_Line (File => Notes_File));
|
||||
end loop;
|
||||
exception
|
||||
when Ada.IO_Exceptions.Name_Error =>
|
||||
null;
|
||||
end;
|
||||
else
|
||||
begin
|
||||
Ada.Text_IO.Open
|
||||
(File => Notes_File,
|
||||
Mode => Ada.Text_IO.Append_File,
|
||||
Name => Notes_Filename);
|
||||
exception
|
||||
when Ada.IO_Exceptions.Name_Error =>
|
||||
Ada.Text_IO.Create (File => Notes_File, Name => Notes_Filename);
|
||||
end;
|
||||
Ada.Text_IO.Put_Line
|
||||
(File => Notes_File,
|
||||
Item => Ada.Calendar.Formatting.Image (Date => Ada.Calendar.Clock));
|
||||
Ada.Text_IO.Put (File => Notes_File, Item => Ada.Characters.Latin_1.HT);
|
||||
for I in 1 .. Argument_Count loop
|
||||
Ada.Text_IO.Put
|
||||
(File => Notes_File,
|
||||
Item => Ada.Command_Line.Argument (I));
|
||||
if I /= Argument_Count then
|
||||
Ada.Text_IO.Put (File => Notes_File, Item => ' ');
|
||||
end if;
|
||||
end loop;
|
||||
Ada.Text_IO.Flush (File => Notes_File);
|
||||
end if;
|
||||
if Ada.Text_IO.Is_Open (File => Notes_File) then
|
||||
Ada.Text_IO.Close (File => Notes_File);
|
||||
end if;
|
||||
end Notes;
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#! /usr/local/bin/aime -a
|
||||
|
||||
if (argc() == 1) {
|
||||
file f;
|
||||
text s;
|
||||
|
||||
f.affix("NOTES.TXT");
|
||||
|
||||
while (~f.line(s)) {
|
||||
o_(s, "\n");
|
||||
}
|
||||
} else {
|
||||
date d;
|
||||
file f;
|
||||
|
||||
f.open("NOTES.TXT", OPEN_APPEND | OPEN_CREATE | OPEN_WRITEONLY, 0644);
|
||||
|
||||
d.now;
|
||||
|
||||
f.form("/f4/-/f2/-/f2/ /f2/:/f2/:/f2/\n", d.year, d.y_month,
|
||||
d.m_day, d.d_hour, d.h_minute, d.m_second);
|
||||
|
||||
for (integer i, text s in 1.args) {
|
||||
f.bytes(i ? ' ' : '\t', s);
|
||||
}
|
||||
|
||||
f.byte('\n');
|
||||
}
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#!/usr/bin/osascript
|
||||
|
||||
-- format a number as a string with leading zero if needed
|
||||
to format(aNumber)
|
||||
set resultString to aNumber as text
|
||||
if length of resultString < 2
|
||||
set resultString to "0" & resultString
|
||||
end if
|
||||
return resultString
|
||||
end format
|
||||
|
||||
-- join a list with a delimiter
|
||||
to concatenation of aList given delimiter:aDelimiter
|
||||
set tid to AppleScript's text item delimiters
|
||||
set AppleScript's text item delimiters to { aDelimiter }
|
||||
set resultString to aList as text
|
||||
set AppleScript's text item delimiters to tid
|
||||
return resultString
|
||||
end join
|
||||
|
||||
-- apply a handler to every item in a list, returning
|
||||
-- a list of the results
|
||||
to mapping of aList given function:aHandler
|
||||
set resultList to {}
|
||||
global h
|
||||
set h to aHandler
|
||||
repeat with anItem in aList
|
||||
set resultList to resultList & h(anItem)
|
||||
end repeat
|
||||
return resultList
|
||||
end mapping
|
||||
|
||||
-- return an ISO-8601-formatted string representing the current date and time
|
||||
-- in UTC
|
||||
to iso8601()
|
||||
set { year:y, month:m, day:d, ¬
|
||||
hours:hr, minutes:min, seconds:sec } to ¬
|
||||
(current date) - (time to GMT)
|
||||
set ymdList to the mapping of { y, m as integer, d } given function:format
|
||||
set ymd to the concatenation of ymdList given delimiter:"-"
|
||||
set hmsList to the mapping of { hr, min, sec } given function:format
|
||||
set hms to the concatenation of hmsList given delimiter:":"
|
||||
set dateTime to the concatenation of {ymd, hms} given delimiter:"T"
|
||||
return dateTime & "Z"
|
||||
end iso8601
|
||||
|
||||
to exists(filePath)
|
||||
try
|
||||
filePath as alias
|
||||
return true
|
||||
on error
|
||||
return false
|
||||
end try
|
||||
end exists
|
||||
|
||||
on run argv
|
||||
set curDir to (do shell script "pwd")
|
||||
set notesFile to POSIX file (curDir & "/NOTES.TXT")
|
||||
|
||||
if (count argv) is 0 then
|
||||
if exists(notesFile) then
|
||||
set text item delimiters to {linefeed}
|
||||
return paragraphs of (read notesFile) as text
|
||||
else
|
||||
log "No notes here."
|
||||
return
|
||||
end if
|
||||
else
|
||||
try
|
||||
set fd to open for access notesFile with write permission
|
||||
write (iso8601() & linefeed & tab) to fd starting at eof
|
||||
set AppleScript's text item delimiters to {" "}
|
||||
write ((argv as text) & linefeed) to fd starting at eof
|
||||
close access fd
|
||||
return true
|
||||
on error errMsg number errNum
|
||||
try
|
||||
close access fd
|
||||
end try
|
||||
return "unable to open " & notesFile & ": " & errMsg
|
||||
end try
|
||||
end if
|
||||
end run
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
notes: "notes.txt"
|
||||
if? empty? arg [
|
||||
if exists? notes -> print read notes
|
||||
]
|
||||
else [
|
||||
output: (to :string now) ++ "\n" ++
|
||||
"\t" ++ (join.with:" " to [:string] arg) ++ "\n"
|
||||
write.append notes output
|
||||
]
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
Notes := "Notes.txt"
|
||||
|
||||
If 0 = 0 ; no arguments
|
||||
{
|
||||
If FileExist(Notes) {
|
||||
FileRead, Content, %Notes%
|
||||
MsgBox, %Content%
|
||||
} Else
|
||||
MsgBox, %Notes% does not exist
|
||||
Goto, EOF
|
||||
}
|
||||
|
||||
; date and time, colon, newline (CRLF), tab
|
||||
Date := A_DD "/" A_MM "/" A_YYYY
|
||||
Time := A_Hour ":" A_Min ":" A_Sec "." A_MSec
|
||||
FileAppend, %Date% %Time%:`r`n%A_Tab%, %Notes%
|
||||
|
||||
; command line parameters, trailing newline (CRLF)
|
||||
Loop, %0%
|
||||
FileAppend, % %A_Index% " ", %Notes%
|
||||
FileAppend, `r`n, %Notes%
|
||||
|
||||
EOF:
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
IF LEN(COMMAND$) THEN
|
||||
OPEN "notes.txt" FOR APPEND AS 1
|
||||
PRINT #1, DATE$, TIME$
|
||||
PRINT #1, CHR$(9); COMMAND$
|
||||
CLOSE
|
||||
ELSE
|
||||
d$ = DIR$("notes.txt")
|
||||
IF LEN(d$) THEN
|
||||
OPEN d$ FOR INPUT AS 1
|
||||
WHILE NOT EOF(1)
|
||||
LINE INPUT #1, i$
|
||||
PRINT i$
|
||||
WEND
|
||||
CLOSE
|
||||
END IF
|
||||
END IF
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
REM!Exefile C:\NOTES.EXE, encrypt, console
|
||||
REM!Embed
|
||||
LF = 10
|
||||
|
||||
SYS "GetStdHandle", -10 TO @hfile%(1)
|
||||
SYS "GetStdHandle", -11 TO @hfile%(2)
|
||||
SYS "SetConsoleMode", @hfile%(1), 0
|
||||
*INPUT 13
|
||||
*OUTPUT 14
|
||||
ON ERROR PRINT REPORT$ : QUIT ERR
|
||||
|
||||
notes% = OPENUP(@dir$ + "NOTES.TXT")
|
||||
IF notes% = 0 notes% = OPENOUT(@dir$ + "NOTES.TXT")
|
||||
IF notes% = 0 PRINT "Cannot open or create NOTES.TXT" : QUIT 1
|
||||
|
||||
IF @cmd$ = "" THEN
|
||||
WHILE NOT EOF#notes%
|
||||
INPUT #notes%, text$
|
||||
IF ASC(text$) = LF text$ = MID$(text$,2)
|
||||
PRINT text$
|
||||
ENDWHILE
|
||||
ELSE
|
||||
PTR#notes% = EXT#notes%
|
||||
PRINT #notes%,TIME$ : BPUT#notes%,LF
|
||||
PRINT #notes%,CHR$(9) + @cmd$ : BPUT#notes%,LF
|
||||
ENDIF
|
||||
|
||||
CLOSE #notes%
|
||||
QUIT
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
@echo off
|
||||
if %1@==@ (
|
||||
if exist notes.txt more notes.txt
|
||||
goto :eof
|
||||
)
|
||||
echo %date% %time%:>>notes.txt
|
||||
echo %*>>notes.txt
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <ctime>
|
||||
using namespace std;
|
||||
|
||||
#define note_file "NOTES.TXT"
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
if(argc>1)
|
||||
{
|
||||
ofstream Notes(note_file, ios::app);
|
||||
time_t timer = time(NULL);
|
||||
if(Notes.is_open())
|
||||
{
|
||||
Notes << asctime(localtime(&timer)) << '\t';
|
||||
for(int i=1;i<argc;i++)
|
||||
Notes << argv[i] << ' ';
|
||||
Notes << endl;
|
||||
Notes.close();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ifstream Notes(note_file, ios::in);
|
||||
string line;
|
||||
if(Notes.is_open())
|
||||
{
|
||||
while(!Notes.eof())
|
||||
{
|
||||
getline(Notes, line);
|
||||
cout << line << endl;
|
||||
}
|
||||
Notes.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
using System;
|
||||
using System.IO;
|
||||
using System.Text;
|
||||
|
||||
namespace RosettaCode
|
||||
{
|
||||
internal class Program
|
||||
{
|
||||
private const string FileName = "NOTES.TXT";
|
||||
|
||||
private static void Main(string[] args)
|
||||
{
|
||||
if (args.Length==0)
|
||||
{
|
||||
string txt = File.ReadAllText(FileName);
|
||||
Console.WriteLine(txt);
|
||||
}
|
||||
else
|
||||
{
|
||||
var sb = new StringBuilder();
|
||||
sb.Append(DateTime.Now).Append("\n\t");
|
||||
foreach (string s in args)
|
||||
sb.Append(s).Append(" ");
|
||||
sb.Append("\n");
|
||||
|
||||
if (File.Exists(FileName))
|
||||
File.AppendAllText(FileName, sb.ToString());
|
||||
else
|
||||
File.WriteAllText(FileName, sb.ToString());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
#include <stdio.h>
|
||||
#include <time.h>
|
||||
|
||||
#define note_file "NOTES.TXT"
|
||||
|
||||
int main(int argc, char**argv)
|
||||
{
|
||||
FILE *note = 0;
|
||||
time_t tm;
|
||||
int i;
|
||||
char *p;
|
||||
|
||||
if (argc < 2) {
|
||||
if ((note = fopen(note_file, "r")))
|
||||
while ((i = fgetc(note)) != EOF)
|
||||
putchar(i);
|
||||
|
||||
} else if ((note = fopen(note_file, "a"))) {
|
||||
tm = time(0);
|
||||
p = ctime(&tm);
|
||||
|
||||
/* skip the newline */
|
||||
while (*p) fputc(*p != '\n'?*p:'\t', note), p++;
|
||||
|
||||
for (i = 1; i < argc; i++)
|
||||
fprintf(note, "%s%c", argv[i], 1 + i - argc ? ' ' : '\n');
|
||||
}
|
||||
|
||||
if (note) fclose(note);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
% This program uses the "get_argv" function that is supplied iwth
|
||||
% PCLU in "useful.lib".
|
||||
|
||||
NOTEFILE = "notes.txt"
|
||||
|
||||
% Format the date and time as MM/DD/YYYY HH:MM:SS [AM|PM]
|
||||
format_date = proc (d: date) returns (string)
|
||||
ds: stream := stream$create_output()
|
||||
stream$putzero(ds, int$unparse(d.month), 2)
|
||||
stream$putc(ds, '/')
|
||||
stream$putzero(ds, int$unparse(d.day), 2)
|
||||
stream$putc(ds, '/')
|
||||
stream$putzero(ds, int$unparse(d.year), 4)
|
||||
stream$putc(ds, ' ')
|
||||
|
||||
hour: int := d.hour // 12
|
||||
if hour=0 then hour:=12 end
|
||||
ampm: string := "AM"
|
||||
if d.hour>=12 then ampm := "PM" end
|
||||
|
||||
stream$putzero(ds, int$unparse(hour), 2)
|
||||
stream$putc(ds, ':')
|
||||
stream$putzero(ds, int$unparse(d.minute), 2)
|
||||
stream$putc(ds, ':')
|
||||
stream$putzero(ds, int$unparse(d.second), 2)
|
||||
stream$putc(ds, ' ')
|
||||
stream$puts(ds, ampm)
|
||||
return(stream$get_contents(ds))
|
||||
end format_date
|
||||
|
||||
% Add a note to the file
|
||||
add_note = proc (note: sequence[string])
|
||||
fn: file_name := file_name$parse(NOTEFILE)
|
||||
out: stream := stream$open(fn, "append")
|
||||
stream$putl(out, format_date(now()))
|
||||
|
||||
c: char := '\t'
|
||||
for part: string in sequence[string]$elements(note) do
|
||||
stream$putc(out, c)
|
||||
stream$puts(out, part)
|
||||
c := ' '
|
||||
end
|
||||
stream$putc(out, '\n')
|
||||
stream$close(out)
|
||||
end add_note
|
||||
|
||||
% Show the notes file, if it exists
|
||||
show_notes = proc ()
|
||||
po: stream := stream$primary_output()
|
||||
fn: file_name := file_name$parse(NOTEFILE)
|
||||
begin
|
||||
inp: stream := stream$open(fn, "read")
|
||||
while true do
|
||||
stream$putl(po, stream$getl(inp))
|
||||
except when end_of_file: break end
|
||||
end
|
||||
stream$close(inp)
|
||||
end except when not_possible(s: string): end
|
||||
end show_notes
|
||||
|
||||
% Add a note if one is given, show the notes otherwise
|
||||
start_up = proc ()
|
||||
note: sequence[string] := get_argv()
|
||||
if sequence[string]$empty(note)
|
||||
then show_notes()
|
||||
else add_note(note)
|
||||
end
|
||||
end start_up
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
IDENTIFICATION DIVISION.
|
||||
PROGRAM-ID. NOTES.
|
||||
|
||||
ENVIRONMENT DIVISION.
|
||||
INPUT-OUTPUT SECTION.
|
||||
FILE-CONTROL.
|
||||
SELECT OPTIONAL notes ASSIGN TO "NOTES.TXT"
|
||||
ORGANIZATION LINE SEQUENTIAL
|
||||
FILE STATUS note-status.
|
||||
|
||||
DATA DIVISION.
|
||||
FILE SECTION.
|
||||
FD notes.
|
||||
01 note-record PIC X(256).
|
||||
|
||||
LOCAL-STORAGE SECTION.
|
||||
01 note-status PIC 99.
|
||||
88 notes-ok VALUE 0 THRU 9.
|
||||
|
||||
01 date-now.
|
||||
03 current-year PIC 9(4).
|
||||
03 current-month PIC 99.
|
||||
03 current-day PIC 99.
|
||||
|
||||
01 time-now.
|
||||
03 current-hour PIC 99.
|
||||
03 current-min PIC 99.
|
||||
03 current-sec PIC 99.
|
||||
|
||||
01 args PIC X(256).
|
||||
|
||||
PROCEDURE DIVISION.
|
||||
DECLARATIVES.
|
||||
note-error SECTION.
|
||||
USE AFTER STANDARD ERROR PROCEDURE ON notes.
|
||||
|
||||
DISPLAY "Error using NOTES.TXT. Error code: " note-status
|
||||
.
|
||||
END DECLARATIVES.
|
||||
|
||||
main.
|
||||
ACCEPT args FROM COMMAND-LINE
|
||||
|
||||
* *> If there are no args, display contents of NOTES.TXT.
|
||||
IF args = SPACES
|
||||
OPEN INPUT notes
|
||||
|
||||
PERFORM FOREVER
|
||||
* *> READ has no syntax highlighting, but END-READ does.
|
||||
* *> Go figure.
|
||||
READ notes
|
||||
AT END
|
||||
EXIT PERFORM
|
||||
|
||||
NOT AT END
|
||||
DISPLAY FUNCTION TRIM(note-record)
|
||||
END-READ
|
||||
END-PERFORM
|
||||
ELSE
|
||||
OPEN EXTEND notes
|
||||
|
||||
* *> Write date and time to file.
|
||||
ACCEPT date-now FROM DATE YYYYMMDD
|
||||
ACCEPT time-now FROM TIME
|
||||
STRING current-year "-" current-month "-" current-day
|
||||
" " current-hour ":" current-min ":" current-sec
|
||||
INTO note-record
|
||||
WRITE note-record
|
||||
|
||||
* *> Write arguments to file as they were passed.
|
||||
STRING X"09", args INTO note-record
|
||||
WRITE note-record
|
||||
END-IF
|
||||
|
||||
CLOSE notes
|
||||
|
||||
GOBACK
|
||||
.
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
(ns rosettacode.notes
|
||||
(:use [clojure.string :only [join]]))
|
||||
|
||||
(defn notes [notes]
|
||||
(if (seq notes)
|
||||
(spit
|
||||
"NOTES.txt"
|
||||
(str (java.util.Date.) "\n" "\t"
|
||||
(join " " notes) "\n")
|
||||
:append true)
|
||||
(println (slurp "NOTES.txt"))))
|
||||
|
||||
(notes *command-line-args*)
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
(defparameter *notes* "NOTES.TXT")
|
||||
|
||||
(defun format-date-time (stream)
|
||||
(multiple-value-bind (second minute hour date month year) (get-decoded-time)
|
||||
(format stream "~D-~2,'0D-~2,'0D ~2,'0D:~2,'0D:~2,'0D"
|
||||
year month date hour minute second)))
|
||||
|
||||
(defun notes (args)
|
||||
(if args
|
||||
(with-open-file (s *notes* :direction :output
|
||||
:if-exists :append
|
||||
:if-does-not-exist :create)
|
||||
(format-date-time s)
|
||||
(format s "~&~A~{~A~^ ~}~%" #\Tab args))
|
||||
(with-open-file (s *notes* :if-does-not-exist nil)
|
||||
(when s
|
||||
(loop for line = (read-line s nil)
|
||||
while line
|
||||
do (write-line line))))))
|
||||
|
||||
(defun main ()
|
||||
(notes (uiop:command-line-arguments)))
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
void main(in string[] args) {
|
||||
import std.stdio, std.file, std.datetime, std.range;
|
||||
|
||||
immutable filename = "NOTES.TXT";
|
||||
|
||||
if (args.length == 1) {
|
||||
if (filename.exists && filename.isFile)
|
||||
writefln("%-(%s\n%)", filename.File.byLine);
|
||||
} else {
|
||||
auto f = File(filename, "a+");
|
||||
f.writefln("%s", cast(DateTime)Clock.currTime);
|
||||
f.writefln("\t%-(%s %)", args.dropOne);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
program notes;
|
||||
|
||||
{$APPTYPE CONSOLE}
|
||||
|
||||
uses
|
||||
Classes,
|
||||
SysUtils,
|
||||
IOUtils;
|
||||
|
||||
const
|
||||
FILENAME = 'NOTES.TXT';
|
||||
TAB = #9;
|
||||
|
||||
var
|
||||
sw: TStreamWriter;
|
||||
i : integer;
|
||||
|
||||
begin
|
||||
if ParamCount = 0 then
|
||||
begin
|
||||
if TFile.Exists(FILENAME) then
|
||||
write(TFile.ReadAllText(FILENAME));
|
||||
end
|
||||
else
|
||||
begin
|
||||
if TFile.Exists(FILENAME) then
|
||||
sw := TFile.AppendText(FILENAME)
|
||||
else
|
||||
sw := TFile.CreateText(FILENAME);
|
||||
|
||||
sw.Write(FormatDateTime('yyyy-mm-dd hh:nn',Now));
|
||||
sw.Write(TAB);
|
||||
for i := 1 to ParamCount do
|
||||
begin
|
||||
sw.Write(ParamStr(i));
|
||||
if i < ParamCount then
|
||||
sw.Write(' ');
|
||||
end;
|
||||
sw.WriteLine;
|
||||
sw.Free;
|
||||
end;
|
||||
end.
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
#!/usr/bin/env rune
|
||||
|
||||
def f := <file:notes.txt>
|
||||
def date := makeCommand("date")
|
||||
|
||||
switch (interp.getArgs()) {
|
||||
match [] {
|
||||
if (f.exists()) {
|
||||
for line in f { print(line) }
|
||||
}
|
||||
}
|
||||
match noteArgs {
|
||||
def w := f.textWriter(true)
|
||||
w.print(date()[0], "\t", " ".rjoin(noteArgs), "\n")
|
||||
w.close()
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
defmodule Take_notes do
|
||||
@filename "NOTES.TXT"
|
||||
|
||||
def main( [] ), do: display_notes
|
||||
def main( arguments ), do: save_notes( arguments )
|
||||
|
||||
def display_notes, do: IO.puts File.read!(@filename)
|
||||
|
||||
def save_notes( arguments ) do
|
||||
notes = "#{inspect :calendar.local_time}\n\t" <> Enum.join(arguments, " ")
|
||||
File.open!(@filename, [:append], fn(file) -> IO.puts(file, notes) end)
|
||||
end
|
||||
end
|
||||
|
||||
Take_notes.main(System.argv)
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#! /usr/bin/env escript
|
||||
|
||||
main( Arguments ) ->
|
||||
display_notes( Arguments ),
|
||||
save_notes( Arguments ).
|
||||
|
||||
|
||||
|
||||
display_notes( [] ) -> io:fwrite( "~s", [erlang:binary_to_list(file_contents())] );
|
||||
display_notes( _Arguments ) -> ok.
|
||||
|
||||
file() -> "NOTES.TXT".
|
||||
|
||||
file_contents() -> file_contents( file:read_file(file()) ).
|
||||
|
||||
file_contents( {ok, Binary} ) -> Binary;
|
||||
file_contents( {error, _Error} ) -> <<>>.
|
||||
|
||||
save_notes( [] ) -> ok;
|
||||
save_notes( Arguments ) ->
|
||||
Date = io_lib:format( "~p~n", [calendar:local_time()] ),
|
||||
Notes = [Date ++ "\t" | [io_lib:format( "~s ", [X]) || X <- Arguments]],
|
||||
Existing_contents = file_contents(),
|
||||
file:write_file( file(), [Existing_contents, Notes, "\n"] ).
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
constant cmd = command_line()
|
||||
constant filename = "notes.txt"
|
||||
integer fn
|
||||
object line
|
||||
sequence date_time
|
||||
|
||||
if length(cmd) < 3 then
|
||||
fn = open(filename,"r")
|
||||
if fn != -1 then
|
||||
while 1 do
|
||||
line = gets(fn)
|
||||
if atom(line) then
|
||||
exit
|
||||
end if
|
||||
puts(1,line)
|
||||
end while
|
||||
close(fn)
|
||||
end if
|
||||
else
|
||||
fn = open(filename,"a") -- if such file doesn't exist it will be created
|
||||
date_time = date()
|
||||
date_time = date_time[1..6]
|
||||
date_time[1] += 1900
|
||||
printf(fn,"%d-%02d-%02d %d:%02d:%02d\n",date_time)
|
||||
line = "\t"
|
||||
for n = 3 to length(cmd) do
|
||||
line &= cmd[n] & ' '
|
||||
end for
|
||||
line[$] = '\n'
|
||||
puts(fn,line)
|
||||
close(fn)
|
||||
end if
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
open System;;
|
||||
open System.IO;;
|
||||
|
||||
let file_path = "notes.txt";;
|
||||
|
||||
let show_notes () =
|
||||
try
|
||||
printfn "%s" <| File.ReadAllText(file_path)
|
||||
with
|
||||
_ -> printfn "Take some notes first!";;
|
||||
|
||||
let take_note (note : string) =
|
||||
let now = DateTime.Now.ToString() in
|
||||
let note = sprintf "%s\n\t%s" now note in
|
||||
use file_stream = File.AppendText file_path in (* 'use' closes file_stream automatically when control leaves the scope *)
|
||||
file_stream.WriteLine note;;
|
||||
|
||||
[<EntryPoint>]
|
||||
let main args =
|
||||
match Array.length args with
|
||||
| 0 -> show_notes()
|
||||
| _ -> take_note <| String.concat " " args;
|
||||
0;;
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
#! /usr/bin/env factor
|
||||
USING: kernel calendar calendar.format io io.encodings.utf8 io.files
|
||||
sequences command-line namespaces ;
|
||||
|
||||
command-line get [
|
||||
"notes.txt" utf8 file-contents print
|
||||
] [
|
||||
" " join "\t" prepend
|
||||
"notes.txt" utf8 [
|
||||
now timestamp>ymdhms print
|
||||
print flush
|
||||
] with-file-appender
|
||||
] if-empty
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
class Notes
|
||||
{
|
||||
public static Void main (Str[] args)
|
||||
{
|
||||
notesFile := File(`notes.txt`) // the backticks make a URI
|
||||
if (args.isEmpty)
|
||||
{
|
||||
if (notesFile.exists)
|
||||
{
|
||||
notesFile.eachLine |line| { echo (line) }
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// notice the following uses a block so the 'printLine/close'
|
||||
// operations are all applied to the same output stream for notesFile
|
||||
notesFile.out(true) // 'true' to append to file
|
||||
{
|
||||
printLine ( DateTime.now.toLocale("DD-MM-YY hh:mm:ss").toStr )
|
||||
printLine ( "\t" + args.join(" ") )
|
||||
close
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
vocabulary note-words
|
||||
get-current also note-words definitions
|
||||
|
||||
\ -- notes.txt
|
||||
variable file
|
||||
: open s" notes.txt" r/w open-file if
|
||||
s" notes.txt" r/w create-file throw then file ! ;
|
||||
: appending file @ file-size throw file @ reposition-file throw ;
|
||||
: write file @ write-file throw ;
|
||||
: close file @ close-file throw ;
|
||||
|
||||
\ -- SwiftForth console workaround
|
||||
9 constant TAB
|
||||
: type ( c-addr u -- )
|
||||
bounds ?do
|
||||
i c@ dup TAB = if drop 8 spaces else emit then
|
||||
loop ;
|
||||
|
||||
\ -- dump notes.txt
|
||||
create buf 4096 allot
|
||||
: dump ( -- )
|
||||
cr begin buf 4096 file @ read-file throw dup while
|
||||
buf swap type
|
||||
repeat drop ;
|
||||
|
||||
\ -- time and date
|
||||
: time @time (time) ;
|
||||
: date @date (date) ;
|
||||
|
||||
\ -- add note
|
||||
: cr s\" \n" write ;
|
||||
: tab s\" \t" write ;
|
||||
: space s" " write ;
|
||||
: add-note ( c-addr u -- ) appending
|
||||
date write space time write cr
|
||||
tab ( note ) write cr ;
|
||||
|
||||
set-current
|
||||
|
||||
\ -- note
|
||||
: note ( "note" -- )
|
||||
open 0 parse dup if add-note
|
||||
else 2drop dump then close ;
|
||||
previous
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
\ -- notes.txt
|
||||
include lib/argopen.4th
|
||||
include lib/ansfacil.4th
|
||||
|
||||
\ -- dump notes.txt
|
||||
4096 buffer: buf
|
||||
: dump ( -- )
|
||||
input 1 arg-open
|
||||
begin buf dup 4096 accept dup while type repeat
|
||||
drop drop close ;
|
||||
|
||||
\ -- time and date
|
||||
: :00 <# # # [char] : hold #> type ;
|
||||
: -00 <# # # [char] - hold #> type ;
|
||||
: .time 0 .r :00 :00 ;
|
||||
: .date 0 .r -00 -00 ;
|
||||
|
||||
\ -- add note
|
||||
: add-note ( c-addr u -- )
|
||||
output append [+] 1 arg-open -rot
|
||||
time&date .date space .time cr
|
||||
9 emit type cr close ;
|
||||
|
||||
\ -- note
|
||||
: note ( "note" -- )
|
||||
argn 2 < abort" Usage: notes filename"
|
||||
refill drop 0 parse dup if add-note else 2drop dump then ;
|
||||
|
||||
note
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
program notes
|
||||
implicit none
|
||||
integer :: i, length, iargs, lun, ios
|
||||
integer,dimension(8) :: values
|
||||
character(len=:),allocatable :: arg
|
||||
character(len=256) :: line
|
||||
character(len=1),parameter :: tab=char(9)
|
||||
iargs = command_argument_count()
|
||||
open(file='notes.txt',newunit=lun,action='readwrite',position='append',status='unknown')
|
||||
if(iargs.eq.0)then
|
||||
rewind(lun)
|
||||
do
|
||||
read(lun,'(a)',iostat=ios)line
|
||||
if(ios.ne.0)exit
|
||||
write(*,'(a)')trim(line)
|
||||
enddo
|
||||
else
|
||||
call date_and_time(VALUES=values)
|
||||
write(lun,'(*(g0))')values(1),"-",values(2),"-",values(3),"T",values(5),":",values(6),":",values(7)
|
||||
write(lun,'(a)',advance='no')tab
|
||||
do i=1,iargs
|
||||
call get_command_argument(number=i,length=length)
|
||||
arg=repeat(' ',length)
|
||||
call get_command_argument(i, arg)
|
||||
write(lun,'(a,1x)',advance='no')arg
|
||||
enddo
|
||||
write(lun,*)
|
||||
endif
|
||||
end program notes
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
If Len(Command) Then
|
||||
Open "notes.txt" For Append As #1
|
||||
Print #1, Date, Time
|
||||
Print #1, Chr(9); Command
|
||||
Close
|
||||
Else
|
||||
If Open("notes.txt" For Input As #1) = 0 Then
|
||||
Dim As String lin
|
||||
Print "Contenido del archivo:"
|
||||
Do While Not Eof(1)
|
||||
Line Input #1, lin
|
||||
Print lin
|
||||
Loop
|
||||
Else
|
||||
Open "notes.txt" For Output As #1
|
||||
Print "Archivo 'NOTES.TXT' creado"
|
||||
End If
|
||||
End If
|
||||
Close #1
|
||||
Sleep
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
'Note that the 1st item in 'Args' is the file name as on the command line './CLIOnly.gambas'
|
||||
|
||||
Public Sub Main()
|
||||
Dim sContents As String 'To store the file contents
|
||||
Dim sArgs As String[] = Args.All 'To store all the Command line Arguments
|
||||
|
||||
If Not Exist(User.home &/ "NOTES.TXT") Then 'If NOTES.TXT doesn't already exist in the current directory then..
|
||||
File.Save(User.home &/ "NOTES.TXT", "") 'a new NOTES.TXT file should be created.
|
||||
Print "New file 'NOTES.TXT' created." 'A meassge
|
||||
Endif
|
||||
|
||||
sContents = File.Load(User.home &/ "NOTES.TXT") 'Get the contents of the file
|
||||
|
||||
If Args.count < 2 Then 'If NOTES has arguments (other than the file name)
|
||||
Print sContents 'Print the file contents
|
||||
Else
|
||||
sContents &= Format(Now, "dddd dd mmmm, yyyy, hh:nn:ss") & gb.NewLine & 'The current date and time are appended to the local NOTES.TXT followed by a newline and..
|
||||
gb.Tab & sArgs.Join(" ") & gb.NewLine 'Then all the arguments, joined with spaces, prepended with a tab, and appended with a trailing newline
|
||||
Print sContents 'Displays the current contents of the local NOTES.TXT
|
||||
File.Save(User.home &/ "NOTES.TXT", sContents) 'Write contents to NOTES.TXT
|
||||
Endif
|
||||
|
||||
End
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
func addNote(fn string, note string) error {
|
||||
f, err := os.OpenFile(fn, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = fmt.Fprint(f, time.Now().Format(time.RFC1123), "\n\t", note, "\n")
|
||||
// To be extra careful with errors from Close():
|
||||
if cErr := f.Close(); err == nil {
|
||||
err = cErr
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func showNotes(w io.Writer, fn string) error {
|
||||
f, err := os.Open(fn)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return nil // don't report "no such file"
|
||||
}
|
||||
return err
|
||||
}
|
||||
_, err = io.Copy(w, f)
|
||||
f.Close()
|
||||
return err
|
||||
}
|
||||
|
||||
func main() {
|
||||
const fn = "NOTES.TXT"
|
||||
var err error
|
||||
if len(os.Args) > 1 {
|
||||
err = addNote(fn, strings.Join(os.Args[1:], " "))
|
||||
} else {
|
||||
err = showNotes(os.Stdout, fn)
|
||||
}
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
def notes = new File('./notes.txt')
|
||||
if (args) {
|
||||
notes << "${new Date().format('YYYY-MM-dd HH:mm:ss')}\t${args.join(' ')}\n"
|
||||
} else {
|
||||
println notes.text
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
import System.Environment (getArgs)
|
||||
import System.Time (getClockTime)
|
||||
|
||||
main :: IO ()
|
||||
main = do
|
||||
args <- getArgs
|
||||
if null args
|
||||
then catch (readFile "notes.txt" >>= putStr)
|
||||
(\_ -> return ())
|
||||
else
|
||||
do ct <- getClockTime
|
||||
appendFile "notes.txt" $ show ct ++ "\n\t" ++ unwords args ++ "\n"
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
SYSTEM(RUN) ! start this script in RUN-mode
|
||||
|
||||
CHARACTER notes="Notes.txt", txt*1000
|
||||
|
||||
! Remove file name from the global variable $CMD_LINE:
|
||||
EDIT(Text=$CMD_LINE, Mark1, Right=".hic ", Right=4, Mark2, Delete)
|
||||
|
||||
IF($CMD_LINE == ' ') THEN
|
||||
READ(FIle=notes, LENgth=Lnotes)
|
||||
IF( Lnotes ) THEN
|
||||
WINDOW(WINdowhandle=hdl, TItle=notes)
|
||||
WRITE(Messagebox="?Y") "Finished ?"
|
||||
ENDIF
|
||||
ELSE
|
||||
WRITE(Text=txt, Format="UWWW CCYY-MM-DD HH:mm:SS, A") 0, $CRLF//$TAB//TRIM($CMD_LINE)//$CRLF
|
||||
OPEN(FIle=notes, APPend)
|
||||
WRITE(FIle=notes, CLoSe=1) txt
|
||||
ENDIF
|
||||
|
||||
ALARM(999) ! quit HicEst immediately
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
procedure write_out_notes (filename)
|
||||
file := open (filename, "rt") | stop ("no notes file yet")
|
||||
every write (!file)
|
||||
end
|
||||
|
||||
procedure add_to_notes (filename, strs)
|
||||
file := open (filename, "at") | # append to file if it exists
|
||||
open (filename, "cat") | # create the file if not there
|
||||
stop ("unable to open " || filename)
|
||||
writes (file, ctime(&now) || "\n\t")
|
||||
every writes (file, !strs || " ")
|
||||
write (file, "")
|
||||
end
|
||||
|
||||
procedure main (args)
|
||||
notes_file := "notes.txt"
|
||||
if *args = 0
|
||||
then write_out_notes (notes_file)
|
||||
else add_to_notes (notes_file, args)
|
||||
end
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
#!/usr/bin/ijconsole
|
||||
require 'files strings'
|
||||
|
||||
notes=: monad define
|
||||
if. #y do.
|
||||
now=. LF ,~ 6!:0 'hh:mm:ss DD/MM/YYYY'
|
||||
'notes.txt' fappend~ now, LF ,~ TAB, ' ' joinstring y
|
||||
elseif. -. _1 -: txt=. fread 'notes.txt' do.
|
||||
smoutput txt
|
||||
end.
|
||||
)
|
||||
|
||||
notes 2}.ARGV
|
||||
exit 0
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
import java.io.*;
|
||||
import java.nio.channels.*;
|
||||
import java.util.Date;
|
||||
|
||||
public class TakeNotes {
|
||||
public static void main(String[] args) throws IOException {
|
||||
if (args.length > 0) {
|
||||
PrintStream ps = new PrintStream(new FileOutputStream("notes.txt", true));
|
||||
ps.println(new Date());
|
||||
ps.print("\t" + args[0]);
|
||||
for (int i = 1; i < args.length; i++)
|
||||
ps.print(" " + args[i]);
|
||||
ps.println();
|
||||
ps.close();
|
||||
} else {
|
||||
FileChannel fc = new FileInputStream("notes.txt").getChannel();
|
||||
fc.transferTo(0, fc.size(), Channels.newChannel(System.out));
|
||||
fc.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
var notes = 'NOTES.TXT';
|
||||
|
||||
var args = WScript.Arguments;
|
||||
var fso = new ActiveXObject("Scripting.FileSystemObject");
|
||||
var ForReading = 1, ForWriting = 2, ForAppending = 8;
|
||||
|
||||
if (args.length == 0) {
|
||||
if (fso.FileExists(notes)) {
|
||||
var f = fso.OpenTextFile(notes, ForReading);
|
||||
WScript.Echo(f.ReadAll());
|
||||
f.Close();
|
||||
}
|
||||
}
|
||||
else {
|
||||
var f = fso.OpenTextFile(notes, ForAppending, true);
|
||||
var d = new Date();
|
||||
f.WriteLine(d.toLocaleString());
|
||||
f.Write("\t");
|
||||
// note that WScript.Arguments is not an array, it is a "collection"
|
||||
// it does not have a join() method.
|
||||
for (var i = 0; i < args.length; i++) {
|
||||
f.Write(args(i) + " ");
|
||||
}
|
||||
f.WriteLine();
|
||||
f.Close();
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
using Dates
|
||||
|
||||
const filename = "NOTES.TXT"
|
||||
|
||||
if length(ARGS) == 0
|
||||
fp = open(filename, "r")
|
||||
println(read(fp, String))
|
||||
else
|
||||
fp = open(filename, "a+")
|
||||
write(fp, string(DateTime(now()), "\n\t", join(ARGS, " "), "\n"))
|
||||
end
|
||||
close(fp)
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
// version 1.2.10
|
||||
|
||||
import java.io.File
|
||||
import java.util.Date
|
||||
import java.text.SimpleDateFormat
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
val f = File("NOTES.TXT")
|
||||
// create file if it doesn't exist already
|
||||
f.createNewFile()
|
||||
if (args.size == 0) {
|
||||
println(f.readText())
|
||||
}
|
||||
else {
|
||||
val df = SimpleDateFormat("yyyy/MM/dd HH:mm:ss")
|
||||
val dt = df.format(Date())
|
||||
val notes = "$dt\n\t${args.joinToString(" ")}\n"
|
||||
f.appendText(notes)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
#!/usr/bin/lasso9
|
||||
|
||||
local(
|
||||
arguments = $argv -> asarray,
|
||||
notesfile = file('notes.txt')
|
||||
)
|
||||
|
||||
#arguments -> removefirst
|
||||
|
||||
if(#arguments -> size) => {
|
||||
|
||||
#notesfile -> openappend
|
||||
#notesfile -> dowithclose => {
|
||||
#notesfile -> writestring(date -> format(`YYYY-MM-dd HH:mm:SS`) + '\n')
|
||||
#notesfile -> writestring('\t' + #arguments -> join(', ') + '\n')
|
||||
}
|
||||
|
||||
|
||||
|
||||
else
|
||||
#notesfile -> exists ? stdout(#notesfile -> readstring)
|
||||
}
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
./notes "Rosetta was here" Räksmörgås
|
||||
./notes First Second Last
|
||||
./notes
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
filename = "NOTES.TXT"
|
||||
|
||||
if #arg == 0 then
|
||||
fp = io.open( filename, "r" )
|
||||
if fp ~= nil then
|
||||
print( fp:read( "*all*" ) )
|
||||
fp:close()
|
||||
end
|
||||
else
|
||||
fp = io.open( filename, "a+" )
|
||||
|
||||
fp:write( os.date( "%x %X\n" ) )
|
||||
|
||||
fp:write( "\t" )
|
||||
for i = 1, #arg do
|
||||
fp:write( arg[i], " " )
|
||||
end
|
||||
fp:write( "\n" )
|
||||
|
||||
fp:close()
|
||||
end
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
MODULE GLOBAL interpret {
|
||||
global filename$="notes.txt"
|
||||
declare FreeConsole lib "Kernel32.FreeConsole"
|
||||
declare GetStdHandle lib "Kernel32.GetStdHandle" {long a}
|
||||
declare AttachConsole lib "Kernel32.AttachConsole" {long a}
|
||||
declare CloseHandle lib "Kernel32.CloseHandle" {long a}
|
||||
declare global WriteCons Lib "Kernel32.WriteConsoleW" {long cons, a$, long n, Long p, long u}
|
||||
long STD_OUTPUT_HANDLE=-11
|
||||
global retvalue
|
||||
buffer clear retvalue as long
|
||||
ret=AttachConsole(-1)
|
||||
if ret=0 then beep: exit
|
||||
global m=GetStdHandle(STD_OUTPUT_HANDLE)
|
||||
if not islet then
|
||||
try {
|
||||
open "notes.bat" for output as #f
|
||||
print #f, {@}+appdir$+{m2000.exe data {%*}: dir %cd%:load notes
|
||||
}
|
||||
close #f
|
||||
}
|
||||
PrintConsoleLn("")
|
||||
dos "notes.bat"
|
||||
else
|
||||
read cmd$
|
||||
cmd$=trim$(cmd$)
|
||||
if cmd$="" then
|
||||
if exist(filename$) then
|
||||
open filename$ for wide input exclusive as #f
|
||||
while not eof(#f)
|
||||
line input #f, line$
|
||||
PrintConsoleLn(line$)
|
||||
end while
|
||||
close#
|
||||
end if
|
||||
else
|
||||
if exist(filename$) then
|
||||
try ok {
|
||||
open filename$ for wide append exclusive as #f
|
||||
}
|
||||
else
|
||||
try ok {
|
||||
open filename$ for wide output exclusive as #f
|
||||
}
|
||||
end if
|
||||
if ok then
|
||||
print #f, str$(now+today,"YYYY-MM-DD hh:mm:ss")
|
||||
print #f, chr$(9);@RemoveSpaces$(cmd$)
|
||||
close#f
|
||||
end if
|
||||
end if
|
||||
end if
|
||||
call void closehandle(m)
|
||||
call void freeconsole()
|
||||
Sub PrintConsole(a$)
|
||||
Call Void WriteCons(m, a$, Len(a$), retvalue(0), 0)
|
||||
End Sub
|
||||
Sub PrintConsoleLn(a$)
|
||||
a$+={
|
||||
}
|
||||
Call Void WriteCons(m, a$, Len(a$), retvalue(0), 0)
|
||||
End Sub
|
||||
Function RemoveSpaces$(a$)
|
||||
local b$,c$,i, sk
|
||||
for i=1 to len(a$)
|
||||
b$=mid$(a$,i,1)
|
||||
if sk then
|
||||
c$+=b$
|
||||
if b$=""""then
|
||||
sk=false
|
||||
b$=mid$(a$,i+1,1)
|
||||
if b$<>"" and b$<>" " then c$+=" "
|
||||
end if
|
||||
else.if mid$(a$,i,2)<>" "then
|
||||
c$+=b$:if b$=""""then sk=true
|
||||
end if
|
||||
next
|
||||
=c$
|
||||
End Function
|
||||
}
|
||||
module interpret1 {
|
||||
try {interpret}
|
||||
|
||||
}
|
||||
interpret1: end
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
function notes(varargin)
|
||||
% NOTES can be used for taking notes
|
||||
% usage:
|
||||
% notes displays the content of the file NOTES.TXT
|
||||
% notes arg1 arg2 ...
|
||||
% add the current date, time and arg# to NOTES.TXT
|
||||
%
|
||||
|
||||
filename = 'NOTES.TXT';
|
||||
if nargin==0
|
||||
fid = fopen(filename,'rt');
|
||||
if fid<0, return; end;
|
||||
while ~feof(fid)
|
||||
fprintf('%s\n',fgetl(fid));
|
||||
end;
|
||||
fclose(fid);
|
||||
else
|
||||
fid = fopen(filename,'a+');
|
||||
if fid<0, error('cannot open %s\n',filename); end;
|
||||
fprintf(fid, '%s\n\t%s', datestr(now),varargin{1});
|
||||
for k=2:length(varargin)
|
||||
fprintf(fid, ', %s', varargin{k});
|
||||
end;
|
||||
fprintf(fid,'\n');
|
||||
fclose(fid);
|
||||
end;
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
If[Length[$CommandLine < 11], str = OpenRead["NOTES.TXT"];
|
||||
Print[ReadString[str, EndOfFile]]; Close[str],
|
||||
str = OpenAppend["NOTES.TXT"]; WriteLine[str, DateString[]];
|
||||
WriteLine[str, "\t" <> StringRiffle[$CommandLine[[11 ;;]]]];
|
||||
Close[str]]
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
:- module notes.
|
||||
:- interface.
|
||||
|
||||
:- import_module io.
|
||||
:- pred main(io::di, io::uo) is det.
|
||||
|
||||
:- implementation.
|
||||
|
||||
:- import_module list, time.
|
||||
|
||||
main(!IO) :-
|
||||
io.command_line_arguments(Args, !IO),
|
||||
( if Args = [] then print_notes(!IO) else add_note(Args, !IO) ).
|
||||
|
||||
:- pred print_notes(io::di, io::uo) is det.
|
||||
|
||||
print_notes(!IO) :-
|
||||
io.open_input(notes_filename, InputRes, !IO),
|
||||
(
|
||||
InputRes = ok(Input),
|
||||
io.input_stream_foldl_io(Input, io.write_char, WriteRes, !IO),
|
||||
(
|
||||
WriteRes = ok
|
||||
;
|
||||
WriteRes = error(WriteError),
|
||||
print_io_error(WriteError, !IO)
|
||||
),
|
||||
io.close_input(Input, !IO)
|
||||
;
|
||||
InputRes = error(_InputError)
|
||||
).
|
||||
|
||||
:- pred add_note(list(string)::in, io::di, io::uo) is det.
|
||||
|
||||
add_note(Words, !IO) :-
|
||||
io.open_append(notes_filename, OutputRes, !IO),
|
||||
(
|
||||
OutputRes = ok(Output),
|
||||
time(Time, !IO),
|
||||
io.write_string(Output, ctime(Time), !IO),
|
||||
io.write_char(Output, '\t', !IO),
|
||||
io.write_list(Output, Words, " ", io.write_string, !IO),
|
||||
io.nl(Output, !IO),
|
||||
io.close_output(Output, !IO)
|
||||
;
|
||||
OutputRes = error(OutputError),
|
||||
print_io_error(OutputError, !IO)
|
||||
).
|
||||
|
||||
:- pred print_io_error(io.error::in, io::di, io::uo) is det.
|
||||
|
||||
print_io_error(Error, !IO) :-
|
||||
io.stderr_stream(Stderr, !IO),
|
||||
io.write_string(Stderr, io.error_message(Error), !IO),
|
||||
io.set_exit_status(1, !IO).
|
||||
|
||||
:- func notes_filename = string.
|
||||
|
||||
notes_filename = "NOTES.TXT".
|
||||
|
||||
:- end_module notes.
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
import os, times, strutils
|
||||
|
||||
if paramCount() == 0:
|
||||
try: stdout.write readFile("notes.txt")
|
||||
except IOError: discard
|
||||
else:
|
||||
var f = open("notes.txt", fmAppend)
|
||||
f.writeLine getTime()
|
||||
f.writeLine "\t", commandLineParams().join(" ")
|
||||
f.close()
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
#! /usr/bin/env ocaml
|
||||
#load "unix.cma"
|
||||
|
||||
let notes_file = "notes.txt"
|
||||
|
||||
let take_notes() =
|
||||
let gmt = Unix.gmtime (Unix.time()) in
|
||||
let date =
|
||||
Printf.sprintf "%d-%02d-%02d %02d:%02d:%02d"
|
||||
(1900 + gmt.Unix.tm_year) (1 + gmt.Unix.tm_mon) gmt.Unix.tm_mday
|
||||
gmt.Unix.tm_hour gmt.Unix.tm_min gmt.Unix.tm_sec
|
||||
in
|
||||
let oc = open_out_gen [Open_append; Open_creat; Open_text] 0o644 notes_file in
|
||||
output_string oc (date ^ "\t");
|
||||
output_string oc (String.concat " " (List.tl(Array.to_list Sys.argv)));
|
||||
output_string oc "\n";
|
||||
;;
|
||||
|
||||
let dump_notes() =
|
||||
if not(Sys.file_exists notes_file)
|
||||
then (prerr_endline "no local notes found"; exit 1);
|
||||
let ic = open_in notes_file in
|
||||
try while true do
|
||||
print_endline (input_line ic)
|
||||
done with End_of_file ->
|
||||
close_in ic
|
||||
|
||||
let () =
|
||||
if Array.length Sys.argv = 1
|
||||
then dump_notes()
|
||||
else take_notes()
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
functor
|
||||
import
|
||||
Application
|
||||
Open
|
||||
OS
|
||||
System
|
||||
define
|
||||
fun {TimeStamp}
|
||||
N = {OS.localTime}
|
||||
in
|
||||
(1900+N.year)#"-"#(1+N.mon)#"-"#N.mDay#", "#N.hour#":"#N.min#":"#N.sec
|
||||
end
|
||||
|
||||
fun {Join X|Xr Sep}
|
||||
{FoldL Xr fun {$ Z X} Z#Sep#X end X}
|
||||
end
|
||||
|
||||
case {Application.getArgs plain}
|
||||
of nil then
|
||||
try
|
||||
F = {New Open.file init(name:"notes.txt")}
|
||||
in
|
||||
{System.printInfo {F read(list:$ size:all)}}
|
||||
{F close}
|
||||
catch _ then skip end
|
||||
[] Args then
|
||||
F = {New Open.file init(name:"notes.txt" flags:[write text create append])}
|
||||
in
|
||||
{F write(vs:{TimeStamp}#"\n")}
|
||||
{F write(vs:"\t"#{Join Args " "}#"\n")}
|
||||
{F close}
|
||||
end
|
||||
{Application.exit 0}
|
||||
end
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
#!/usr/bin/php
|
||||
<?php
|
||||
if ($argc > 1)
|
||||
file_put_contents(
|
||||
'notes.txt',
|
||||
date('r')."\n\t".implode(' ', array_slice($argv, 1))."\n",
|
||||
FILE_APPEND
|
||||
);
|
||||
else
|
||||
@readfile('notes.txt');
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
NOTES: procedure (text) options (main); /* 8 April 2014 */
|
||||
declare text character (100) varying;
|
||||
declare note_file file;
|
||||
|
||||
on undefinedfile(note_file) go to file_does_not_exist;
|
||||
open file (note_file) title ('/NOTES.TXT,recsize(100),type(text)');
|
||||
revert error;
|
||||
|
||||
if text = '' then
|
||||
do;
|
||||
on endfile (note_file) stop;
|
||||
|
||||
do forever;
|
||||
get file (note_file) edit (text) (L);
|
||||
put skip list (text);
|
||||
end;
|
||||
end;
|
||||
close file (note_file);
|
||||
open file (note_file) output title ('/NOTES.TXT,recsize(100),type(text),append(y)');
|
||||
|
||||
put file (note_file) skip list (DATETIME('DDMmmYYYY'), TIME());
|
||||
put file (note_file) skip list (text);
|
||||
put file (note_file) skip;
|
||||
|
||||
put skip list ('Appended ' || text || ' to file');
|
||||
|
||||
return;
|
||||
|
||||
file_does_not_exist:
|
||||
revert undefinedfile (note_file);
|
||||
close file (note_file);
|
||||
open file (note_file) output title ('/NOTES.TXT,recsize(100),type(text)');
|
||||
put file (note_file) skip list (DATETIME('DDMmmYYYY'), TIME());
|
||||
put file (note_file) skip list (text);
|
||||
put file (note_file) skip;
|
||||
put skip list ('The file, NOTES.TXT, has been created');
|
||||
end NOTES;
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
{$mode delphi}
|
||||
PROGRAM notes;
|
||||
// Notes: a time-stamped command line notebook
|
||||
// usage: >notes "note"< or >notes< to display contents
|
||||
USES Classes, SysUtils;
|
||||
|
||||
VAR
|
||||
Note : TStringList;
|
||||
Fname : STRING = 'Notes.txt';
|
||||
Dtime : STRING;
|
||||
Ntext : STRING;
|
||||
c : Cardinal;
|
||||
|
||||
BEGIN
|
||||
DTime := FormatDateTime('YYYY-MM-DD-hhnn',Now);
|
||||
Note := TStringList.Create;
|
||||
WITH Note DO BEGIN
|
||||
TRY
|
||||
LoadFromFile(Fname);
|
||||
EXCEPT
|
||||
Add(DTime);
|
||||
NText := 'Notes.txt created.';
|
||||
END;
|
||||
// command line args present:
|
||||
// add note with date & time
|
||||
IF ParamStr(1) <> '' THEN BEGIN
|
||||
NText := ParamStr(1);
|
||||
Add(DTime);
|
||||
Add(NText);
|
||||
SaveToFile(Fname);
|
||||
// command line args absent:
|
||||
// display contents of notebook
|
||||
END ELSE
|
||||
FOR c := 0 TO Count-1 DO
|
||||
Writeln(Note[c]);
|
||||
Free;
|
||||
END;
|
||||
END.
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
my $file = 'notes.txt';
|
||||
if ( @ARGV ) {
|
||||
open NOTES, '>>', $file or die "Can't append to file $file: $!";
|
||||
print NOTES scalar localtime, "\n\t@ARGV\n";
|
||||
} else {
|
||||
open NOTES, '<', $file or die "Can't read file $file: $!";
|
||||
print <NOTES>;
|
||||
}
|
||||
close NOTES;
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
(notonline)-->
|
||||
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (file i/o)</span>
|
||||
<span style="color: #008080;">constant</span> <span style="color: #000000;">cmd</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">command_line</span><span style="color: #0000FF;">(),</span>
|
||||
<span style="color: #000000;">filename</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"notes.txt"</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cmd</span><span style="color: #0000FF;">)<</span><span style="color: #000000;">3</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #004080;">object</span> <span style="color: #000000;">text</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_text</span><span style="color: #0000FF;">(</span><span style="color: #000000;">filename</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span><span style="color: #0000FF;">(</span><span style="color: #000000;">text</span><span style="color: #0000FF;">)?</span><span style="color: #000000;">text</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"<empty>"</span><span style="color: #0000FF;">))</span>
|
||||
<span style="color: #008080;">else</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #000000;">filename</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"a"</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d-%02d-%02d %d:%02d:%02d\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">date</span><span style="color: #0000FF;">())</span>
|
||||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\t%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cmd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">3</span><span style="color: #0000FF;">..$]))</span>
|
||||
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<!--
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
|
||||
|
||||
(load "@lib/misc.l")
|
||||
(if (argv)
|
||||
(out "+notes.txt" (prinl (stamp) "^J^I" (glue " " @)))
|
||||
(and (info "notes.txt") (in "notes.txt" (echo))) )
|
||||
(bye)
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
$notes = "notes.txt"
|
||||
if (($args).length -eq 0) {
|
||||
if(Test-Path $notes) {
|
||||
Get-Content $notes
|
||||
}
|
||||
} else {
|
||||
Get-Date | Add-Content $notes
|
||||
"`t" + $args -join " " | Add-Content $notes
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#FileName="notes.txt"
|
||||
Define argc=CountProgramParameters()
|
||||
If OpenConsole()
|
||||
If argc=0
|
||||
If ReadFile(0,#FileName)
|
||||
While Eof(0)=0
|
||||
PrintN(ReadString(0)) ; No new notes, so present the old
|
||||
Wend
|
||||
CloseFile(0)
|
||||
EndIf
|
||||
Else ; e.g. we have some arguments
|
||||
Define d$=FormatDate("%yyyy-%mm-%dd %hh:%ii:%ss",date())
|
||||
If OpenFile(0,#FileName)
|
||||
Define args$=""
|
||||
While argc
|
||||
args$+" "+ProgramParameter() ; Read all arguments
|
||||
argc-1
|
||||
Wend
|
||||
FileSeek(0,Lof(0)) ; Go to the end of this file
|
||||
WriteStringN(0,d$+#CRLF$+#TAB$+args$) ; Append date & note
|
||||
CloseFile(0)
|
||||
EndIf
|
||||
EndIf
|
||||
EndIf
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
import sys, datetime, shutil
|
||||
|
||||
if len(sys.argv) == 1:
|
||||
try:
|
||||
with open("notes.txt", "r") as f:
|
||||
shutil.copyfileobj(f, sys.stdout)
|
||||
except IOError:
|
||||
pass
|
||||
else:
|
||||
with open("notes.txt", "a") as f:
|
||||
f.write(datetime.datetime.now().isoformat() + "\n")
|
||||
f.write("\t%s\n" % ' '.join(sys.argv[1:]))
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
#!/usr/bin/env Rscript --default-packages=methods
|
||||
|
||||
args <- commandArgs(trailingOnly=TRUE)
|
||||
|
||||
if (length(args) == 0) {
|
||||
conn <- file("notes.txt", 'r')
|
||||
cat(readLines(conn), sep="\n")
|
||||
} else {
|
||||
conn <- file("notes.txt", 'a')
|
||||
cat(file=conn, date(), "\n\t", paste(args, collapse=" "), "\n", sep="")
|
||||
}
|
||||
close(conn)
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
REBOL [
|
||||
Title: "Notes"
|
||||
URL: http://rosettacode.org/wiki/Take_notes_on_the_command_line
|
||||
]
|
||||
|
||||
notes: %notes.txt
|
||||
|
||||
either any [none? args: system/script/args empty? args] [
|
||||
if exists? notes [print read notes]
|
||||
] [
|
||||
write/binary/append notes rejoin [now lf tab args lf]
|
||||
]
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
/*REXX program implements the "NOTES" command (append text to a file from the C.L.).*/
|
||||
timestamp=right(date(),11,0) time() date('W') /*create a (current) date & time stamp.*/
|
||||
nFID = 'NOTES.TXT' /*the fileID of the "notes" file. */
|
||||
|
||||
if 'f2'x==2 then tab="05"x /*this is an EBCDIC system. */
|
||||
else tab="09"x /* " " " ASCII " */
|
||||
|
||||
if arg()==0 then do while lines(nFID) /*No arguments? Then display the file.*/
|
||||
say linein(Nfid) /*display a line of file ──► screen. */
|
||||
end /*while*/
|
||||
else do
|
||||
call lineout nFID,timestamp /*append the timestamp to "notes" file.*/
|
||||
call lineout nFID,tab||arg(1) /* " " text " " " */
|
||||
end
|
||||
/*stick a fork in it, we're all done. */
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
#!/usr/bin/env racket
|
||||
#lang racket
|
||||
(define file "NOTES.TXT")
|
||||
(require racket/date)
|
||||
(command-line #:args notes
|
||||
(if (null? notes)
|
||||
(if (file-exists? file)
|
||||
(call-with-input-file* file
|
||||
(λ(i) (copy-port i (current-output-port))))
|
||||
(raise-user-error 'notes "missing ~a file" file))
|
||||
(call-with-output-file* file #:exists 'append
|
||||
(λ(o) (fprintf o "~a\n\t~a\n"
|
||||
(date->string (current-date) #t)
|
||||
(string-join notes))))))
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
my $file = 'notes.txt';
|
||||
|
||||
multi MAIN() {
|
||||
print slurp($file);
|
||||
}
|
||||
|
||||
multi MAIN(*@note) {
|
||||
my $fh = open($file, :a);
|
||||
$fh.say: DateTime.now, "\n\t", @note;
|
||||
$fh.close;
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
notes = 'NOTES.TXT'
|
||||
if ARGV.empty?
|
||||
File.copy_stream(notes, $stdout) rescue nil
|
||||
else
|
||||
File.open(notes, 'a') {|file| file.puts "%s\n\t%s" % [Time.now, ARGV.join(' ')]}
|
||||
end
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
extern crate chrono;
|
||||
|
||||
use std::fs::OpenOptions;
|
||||
use std::io::{self, BufReader, BufWriter};
|
||||
use std::io::prelude::*;
|
||||
use std::env;
|
||||
|
||||
const FILENAME: &str = "NOTES.TXT";
|
||||
|
||||
fn show_notes() -> Result<(), io::Error> {
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.create(true) // create the file if not found
|
||||
.write(true) // necessary to create the file
|
||||
.open(FILENAME)?;
|
||||
let mut buf_reader = BufReader::new(file);
|
||||
let mut contents = String::new();
|
||||
buf_reader.read_to_string(&mut contents)?;
|
||||
println!("{}", contents);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn add_to_notes(note: &str) -> Result<(), io::Error> {
|
||||
let file = OpenOptions::new()
|
||||
.append(true) // disables overwriting, writes to the end of the file
|
||||
.create(true)
|
||||
.open(FILENAME)?;
|
||||
let mut buf_writer = BufWriter::new(file);
|
||||
|
||||
let date_and_time = chrono::Local::now();
|
||||
writeln!(buf_writer, "{}", date_and_time)?;
|
||||
|
||||
writeln!(buf_writer, "\t{}", note)
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let note = env::args().skip(1).collect::<Vec<_>>();
|
||||
|
||||
if note.is_empty() {
|
||||
show_notes().expect("failed to print NOTES.TXT");
|
||||
} else {
|
||||
add_to_notes(¬e.join(" ")).expect("failed to write to NOTES.TXT");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
#! /usr/local/bin/snobol4 -b
|
||||
a = 2 ;* skip '-b' parameter
|
||||
notefile = "notes.txt"
|
||||
while args = args host(2,a = a + 1) " " :s(while)
|
||||
ident(args) :f(append)
|
||||
noparms input(.notes,io_findunit(),,notefile) :s(display)f(end)
|
||||
display output = notes :s(display)
|
||||
endfile(notes) :(end)
|
||||
append output(.notes,io_findunit(),"A",notefile) :f(end)
|
||||
notes = date()
|
||||
notes = char(9) args
|
||||
end
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
import java.io.{ FileNotFoundException, FileOutputStream, PrintStream }
|
||||
import java.time.LocalDateTime
|
||||
|
||||
object TakeNotes extends App {
|
||||
val notesFileName = "notes.txt"
|
||||
if (args.length > 0) {
|
||||
val ps = new PrintStream(new FileOutputStream(notesFileName, true))
|
||||
ps.println(LocalDateTime.now() + args.mkString("\n\t", " ", "."))
|
||||
ps.close()
|
||||
} else try {
|
||||
io.Source.fromFile(notesFileName).getLines().foreach(println)
|
||||
} catch {
|
||||
case e: FileNotFoundException => println(e.getLocalizedMessage())
|
||||
case e: Throwable => {
|
||||
println("Some other exception type:")
|
||||
e.printStackTrace()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#lang racket
|
||||
(require racket/date)
|
||||
(define *notes* "NOTES.TXT")
|
||||
|
||||
(let ([a (vector->list (current-command-line-arguments))])
|
||||
(cond
|
||||
[(empty? a)
|
||||
(with-handlers ([exn:fail? void])
|
||||
(call-with-input-file *notes*
|
||||
(lambda (fi)
|
||||
(copy-port fi (current-output-port)))))
|
||||
]
|
||||
[else
|
||||
(call-with-output-file *notes*
|
||||
(lambda (fo)
|
||||
(let ([ln (apply string-append (add-between a " "))]
|
||||
[dt (date->string (current-date))])
|
||||
(fprintf fo "~a~n\t~a~n" dt ln)))
|
||||
#:mode 'text #:exists 'append)
|
||||
]))
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
$ include "seed7_05.s7i";
|
||||
$ include "getf.s7i";
|
||||
$ include "time.s7i";
|
||||
|
||||
const string: noteFileName is "NOTES.TXT";
|
||||
|
||||
const proc: main is func
|
||||
local
|
||||
var file: note is STD_NULL;
|
||||
begin
|
||||
if length(argv(PROGRAM)) = 0 then
|
||||
# write NOTES.TXT
|
||||
write(getf(noteFileName));
|
||||
else
|
||||
# Write date & time to NOTES.TXT, and then arguments
|
||||
note := open(noteFileName, "a");
|
||||
if note <> STD_NULL then
|
||||
writeln(note, truncToSecond(time(NOW)));
|
||||
writeln(note, "\t" <& join(argv(PROGRAM), " "));
|
||||
close(note);
|
||||
end if;
|
||||
end if;
|
||||
end func;
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
var file = %f'notes.txt'
|
||||
|
||||
if (ARGV.len > 0) {
|
||||
var fh = file.open_a
|
||||
fh.say(Time.local.ctime + "\n\t" + ARGV.join(" "))
|
||||
fh.close
|
||||
} else {
|
||||
var fh = file.open_r
|
||||
fh && fh.each { .say }
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
import Foundation
|
||||
|
||||
let args = Process.arguments
|
||||
let manager = NSFileManager()
|
||||
let currentPath = manager.currentDirectoryPath
|
||||
var err:NSError?
|
||||
|
||||
// Create file if it doesn't exist
|
||||
if !manager.fileExistsAtPath(currentPath + "/notes.txt") {
|
||||
println("notes.txt doesn't exist")
|
||||
manager.createFileAtPath(currentPath + "/notes.txt", contents: nil, attributes: nil)
|
||||
}
|
||||
|
||||
// handler is what is used to write to the file
|
||||
let handler = NSFileHandle(forUpdatingAtPath: currentPath + "/notes.txt")
|
||||
|
||||
// Print the file if there are no args
|
||||
if args.count == 1 {
|
||||
let str = NSString(contentsOfFile: currentPath + "/notes.txt", encoding: NSUTF8StringEncoding, error: &err)
|
||||
println(str!)
|
||||
exit(0)
|
||||
}
|
||||
|
||||
let time = NSDate()
|
||||
let format = NSDateFormatter()
|
||||
let timeData = (format.stringFromDate(time) + "\n").dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)
|
||||
format.dateFormat = "yyyy.MM.dd 'at' HH:mm:ss zzz"
|
||||
|
||||
// We're writing to the end of the file
|
||||
handler?.seekToEndOfFile()
|
||||
handler?.writeData(timeData!)
|
||||
|
||||
var str = "\t"
|
||||
for i in 1..<args.count {
|
||||
str += args[i] + " "
|
||||
}
|
||||
|
||||
str += "\n"
|
||||
|
||||
let strData = str.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)
|
||||
handler?.writeData(strData!)
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
# Make it easier to change the name of the notes file
|
||||
set notefile notes.txt
|
||||
|
||||
if {$argc} {
|
||||
# Write a message to the file
|
||||
set msg [clock format [clock seconds]]\n\t[join $argv " "]
|
||||
set f [open $notefile a]
|
||||
puts $f $msg
|
||||
close $f
|
||||
} else {
|
||||
# Print the contents of the file
|
||||
catch {
|
||||
set f [open $notefile]
|
||||
fcopy $f stdout
|
||||
close $f
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
#
|
||||
NOTES=$HOME/notes.txt
|
||||
if [[ $# -eq 0 ]] ; then
|
||||
[[ -r $NOTES ]] && more $NOTES
|
||||
else
|
||||
date >> $NOTES
|
||||
echo " $*" >> $NOTES
|
||||
fi
|
||||
|
|
@ -0,0 +1 @@
|
|||
N=~/notes.txt;[[ $# -gt 0 ]] && { date ; echo " $*"; exit 0; } >> $N || [[ -r $N ]] && cat $N
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
NOTES=$HOME/notes.txt
|
||||
if test "x$*" = "x"
|
||||
then
|
||||
if test -r $NOTES
|
||||
then
|
||||
more $NOTES
|
||||
fi
|
||||
else
|
||||
date >> $NOTES
|
||||
echo " $*" >> $NOTES
|
||||
fi
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
Imports System.IO
|
||||
|
||||
Module Notes
|
||||
Function Main(ByVal cmdArgs() As String) As Integer
|
||||
Try
|
||||
If cmdArgs.Length = 0 Then
|
||||
Using sr As New StreamReader("NOTES.TXT")
|
||||
Console.WriteLine(sr.ReadToEnd)
|
||||
End Using
|
||||
Else
|
||||
Using sw As New StreamWriter("NOTES.TXT", True)
|
||||
sw.WriteLine(Date.Now.ToString())
|
||||
sw.WriteLine("{0}{1}", ControlChars.Tab, String.Join(" ", cmdArgs))
|
||||
End Using
|
||||
End If
|
||||
Catch
|
||||
End Try
|
||||
End Function
|
||||
End Module
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
import "os" for Process
|
||||
import "/ioutil" for File, FileUtil
|
||||
import "/date" for Date
|
||||
|
||||
var dateFormatIn = "yyyy|-|mm|-|dd|+|hh|:|MM"
|
||||
var dateFormatOut = "yyyy|-|mm|-|dd| |hh|:|MM"
|
||||
var args = Process.arguments
|
||||
if (args.count == 0) {
|
||||
if (File.exists("NOTES.TXT")) System.print(File.read("NOTES.TXT"))
|
||||
} else if (args.count == 1) {
|
||||
System.print("Enter the current date/time (MM/DD+HH:mm) plus at least one other argument.")
|
||||
} else {
|
||||
var dateTime = Date.parse(args[0], dateFormatIn)
|
||||
var note = "\t" + args[1..-1].join(" ") + "\n"
|
||||
FileUtil.append("NOTES.TXT", dateTime.format(dateFormatOut) + "\n" + note)
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
include xpllib; \Date and Time routines
|
||||
int I, NotesSize, Ch, CmdArgSize;
|
||||
char Notes(1_000_000), CmdArg(1000);
|
||||
[\Read in notes.txt, if it exists
|
||||
Trap(false); \disable abort on errors
|
||||
FSet(FOpen("notes.txt", 0), ^i);
|
||||
OpenI(3);
|
||||
if GetErr = 0 then \file exists
|
||||
[I:= 0;
|
||||
while GetErr = 0 do \GetErr detects end-of-file
|
||||
[Notes(I):= ChIn(3);
|
||||
I:= I+1;
|
||||
];
|
||||
NotesSize:= I-2; \remove 2 EOFs
|
||||
];
|
||||
\Get command-line argument, if any, from command line
|
||||
I:= 0;
|
||||
loop [Ch:= ChIn(8);
|
||||
if Ch = CR then quit;
|
||||
CmdArg(I):= Ch;
|
||||
I:= I+1;
|
||||
];
|
||||
CmdArg(I):= 0; \terminate string
|
||||
if I = 0 then \no args, just display notes.txt
|
||||
for I:= 0 to NotesSize-1 do ChOut(0, Notes(I))
|
||||
else \open notes.txt for output and append CmdArg
|
||||
[FSet(FOpen("notes.txt", 1), ^o);
|
||||
OpenO(3);
|
||||
for I:= 0 to NotesSize-1 do ChOut(3, Notes(I));
|
||||
DateOut(3, GetDosDate); ChOut(3, ^ );
|
||||
TimeOut(3, GetDosTime); CrLf(3);
|
||||
ChOut(3, Tab); Text(3, CmdArg); CrLf(3);
|
||||
Close(3);
|
||||
];
|
||||
]
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
const notesName="NOTES.TXT";
|
||||
args:=vm.arglist;
|
||||
if (not args)
|
||||
{ try{ File(notesName).read(*).text.print(); } catch{println("no file")} }
|
||||
else{
|
||||
f:=File(notesName,"a+");
|
||||
f.writeln(Time.Date.ctime(),"\n\t",args.concat(" "));
|
||||
f.close();
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue